1 /* 2 * Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "classfile/javaClasses.inline.hpp" 27 #include "classfile/moduleEntry.hpp" 28 #include "classfile/vmClasses.hpp" 29 #include "classfile/vmSymbols.hpp" 30 #include "code/nmethod.hpp" 31 #include "code/pcDesc.hpp" 32 #include "code/scopeDesc.hpp" 33 #include "gc/shared/oopStorageSet.hpp" 34 #include "interpreter/interpreter.hpp" 35 #include "jvmtifiles/jvmtiEnv.hpp" 36 #include "logging/log.hpp" 37 #include "logging/logStream.hpp" 38 #include "memory/allocation.inline.hpp" 39 #include "memory/resourceArea.hpp" 40 #include "memory/universe.hpp" 41 #include "oops/klass.inline.hpp" 42 #include "oops/objArrayKlass.hpp" 43 #include "oops/objArrayOop.hpp" 44 #include "oops/oop.inline.hpp" 45 #include "oops/oopHandle.inline.hpp" 46 #include "prims/jvmtiAgentList.hpp" 47 #include "prims/jvmtiCodeBlobEvents.hpp" 48 #include "prims/jvmtiEventController.hpp" 49 #include "prims/jvmtiEventController.inline.hpp" 50 #include "prims/jvmtiExport.hpp" 51 #include "prims/jvmtiImpl.hpp" 52 #include "prims/jvmtiManageCapabilities.hpp" 53 #include "prims/jvmtiRawMonitor.hpp" 54 #include "prims/jvmtiRedefineClasses.hpp" 55 #include "prims/jvmtiTagMap.hpp" 56 #include "prims/jvmtiThreadState.inline.hpp" 57 #include "runtime/arguments.hpp" 58 #include "runtime/fieldDescriptor.inline.hpp" 59 #include "runtime/handles.inline.hpp" 60 #include "runtime/interfaceSupport.inline.hpp" 61 #include "runtime/javaCalls.hpp" 62 #include "runtime/javaThread.hpp" 63 #include "runtime/jniHandles.inline.hpp" 64 #include "runtime/keepStackGCProcessed.hpp" 65 #include "runtime/objectMonitor.hpp" 66 #include "runtime/objectMonitor.inline.hpp" 67 #include "runtime/os.hpp" 68 #include "runtime/osThread.hpp" 69 #include "runtime/safepointVerifiers.hpp" 70 #include "runtime/serviceThread.hpp" 71 #include "runtime/threads.hpp" 72 #include "runtime/threadSMR.hpp" 73 #include "runtime/vframe.inline.hpp" 74 #include "runtime/vm_version.hpp" 75 #include "utilities/macros.hpp" 76 77 #ifdef JVMTI_TRACE 78 #define EVT_TRACE(evt,out) if ((JvmtiTrace::event_trace_flags(evt) & JvmtiTrace::SHOW_EVENT_SENT) != 0) { SafeResourceMark rm; log_trace(jvmti) out; } 79 #define EVT_TRIG_TRACE(evt,out) if ((JvmtiTrace::event_trace_flags(evt) & JvmtiTrace::SHOW_EVENT_TRIGGER) != 0) { SafeResourceMark rm; log_trace(jvmti) out; } 80 #else 81 #define EVT_TRIG_TRACE(evt,out) 82 #define EVT_TRACE(evt,out) 83 #endif 84 85 /////////////////////////////////////////////////////////////// 86 // 87 // JvmtiEventTransition 88 // 89 // TO DO -- 90 // more handle purging 91 92 // Use this for JavaThreads and state is _thread_in_vm. 93 class JvmtiJavaThreadEventTransition : StackObj { 94 private: 95 ResourceMark _rm; 96 ThreadToNativeFromVM _transition; 97 HandleMark _hm; 98 99 public: 100 JvmtiJavaThreadEventTransition(JavaThread *thread) : 101 _rm(), 102 _transition(thread), 103 _hm(thread) {}; 104 }; 105 106 // For JavaThreads which are not in _thread_in_vm state 107 // and other system threads use this. 108 class JvmtiThreadEventTransition : StackObj { 109 private: 110 ResourceMark _rm; 111 HandleMark _hm; 112 JavaThreadState _saved_state; 113 JavaThread *_jthread; 114 115 public: 116 JvmtiThreadEventTransition(Thread *thread) : _rm(), _hm(thread) { 117 if (thread->is_Java_thread()) { 118 _jthread = JavaThread::cast(thread); 119 _saved_state = _jthread->thread_state(); 120 if (_saved_state == _thread_in_Java) { 121 ThreadStateTransition::transition_from_java(_jthread, _thread_in_native); 122 } else { 123 ThreadStateTransition::transition_from_vm(_jthread, _thread_in_native); 124 } 125 } else { 126 _jthread = nullptr; 127 } 128 } 129 130 ~JvmtiThreadEventTransition() { 131 if (_jthread != nullptr) 132 ThreadStateTransition::transition_from_native(_jthread, _saved_state); 133 } 134 }; 135 136 137 /////////////////////////////////////////////////////////////// 138 // 139 // JvmtiEventMark 140 // 141 142 class JvmtiEventMark : public StackObj { 143 private: 144 JavaThread *_thread; 145 JNIEnv* _jni_env; 146 JvmtiThreadState::ExceptionState _saved_exception_state; 147 148 public: 149 JvmtiEventMark(JavaThread *thread) : _thread(thread), 150 _jni_env(thread->jni_environment()), 151 _saved_exception_state(JvmtiThreadState::ES_CLEARED) { 152 JvmtiThreadState *state = thread->jvmti_thread_state(); 153 // we are before an event. 154 // Save current jvmti thread exception state. 155 if (state != nullptr) { 156 _saved_exception_state = state->get_exception_state(); 157 } 158 159 thread->push_jni_handle_block(); 160 assert(thread == JavaThread::current(), "thread must be current!"); 161 thread->frame_anchor()->make_walkable(); 162 }; 163 164 ~JvmtiEventMark() { 165 _thread->pop_jni_handle_block(); 166 167 JvmtiThreadState* state = _thread->jvmti_thread_state(); 168 // we are continuing after an event. 169 if (state != nullptr) { 170 // Restore the jvmti thread exception state. 171 state->restore_exception_state(_saved_exception_state); 172 } 173 } 174 175 jobject to_jobject(oop obj) { return JNIHandles::make_local(_thread,obj); } 176 177 jclass to_jclass(Klass* klass) { return (klass == nullptr ? nullptr : (jclass)to_jobject(klass->java_mirror())); } 178 179 jmethodID to_jmethodID(const methodHandle& method) { return method->jmethod_id(); } 180 181 JNIEnv* jni_env() { return _jni_env; } 182 }; 183 184 class JvmtiThreadEventMark : public JvmtiEventMark { 185 private: 186 jobject _jthread; 187 188 public: 189 JvmtiThreadEventMark(JavaThread *thread) : 190 JvmtiEventMark(thread) { 191 _jthread = to_jobject(thread->threadObj()); 192 }; 193 jthread jni_thread() { return (jthread)_jthread; } 194 }; 195 196 class JvmtiVirtualThreadEventMark : public JvmtiEventMark { 197 private: 198 jobject _jthread; 199 200 public: 201 JvmtiVirtualThreadEventMark(JavaThread *thread) : 202 JvmtiEventMark(thread) { 203 assert(thread->vthread() != nullptr || thread->threadObj() == nullptr, "sanity check"); 204 _jthread = to_jobject(thread->vthread()); 205 }; 206 jthread jni_thread() { return (jthread)_jthread; } 207 }; 208 209 class JvmtiClassEventMark : public JvmtiVirtualThreadEventMark { 210 private: 211 jclass _jc; 212 213 public: 214 JvmtiClassEventMark(JavaThread *thread, Klass* klass) : 215 JvmtiVirtualThreadEventMark(thread) { 216 _jc = to_jclass(klass); 217 }; 218 jclass jni_class() { return _jc; } 219 }; 220 221 class JvmtiMethodEventMark : public JvmtiVirtualThreadEventMark { 222 private: 223 jmethodID _mid; 224 225 public: 226 JvmtiMethodEventMark(JavaThread *thread, const methodHandle& method) : 227 JvmtiVirtualThreadEventMark(thread), 228 _mid(to_jmethodID(method)) {}; 229 jmethodID jni_methodID() { return _mid; } 230 }; 231 232 class JvmtiLocationEventMark : public JvmtiMethodEventMark { 233 private: 234 jlocation _loc; 235 236 public: 237 JvmtiLocationEventMark(JavaThread *thread, const methodHandle& method, address location) : 238 JvmtiMethodEventMark(thread, method), 239 _loc(location - method->code_base()) {}; 240 jlocation location() { return _loc; } 241 }; 242 243 class JvmtiExceptionEventMark : public JvmtiLocationEventMark { 244 private: 245 jobject _exc; 246 247 public: 248 JvmtiExceptionEventMark(JavaThread *thread, const methodHandle& method, address location, Handle exception) : 249 JvmtiLocationEventMark(thread, method, location), 250 _exc(to_jobject(exception())) {}; 251 jobject exception() { return _exc; } 252 }; 253 254 class JvmtiClassFileLoadEventMark : public JvmtiThreadEventMark { 255 private: 256 const char *_class_name; 257 jobject _jloader; 258 jobject _protection_domain; 259 jclass _class_being_redefined; 260 261 public: 262 JvmtiClassFileLoadEventMark(JavaThread *thread, Symbol* name, 263 Handle class_loader, Handle prot_domain, Klass* class_being_redefined) : JvmtiThreadEventMark(thread) { 264 _class_name = name != nullptr? name->as_utf8() : nullptr; 265 _jloader = (jobject)to_jobject(class_loader()); 266 _protection_domain = (jobject)to_jobject(prot_domain()); 267 if (class_being_redefined == nullptr) { 268 _class_being_redefined = nullptr; 269 } else { 270 _class_being_redefined = (jclass)to_jclass(class_being_redefined); 271 } 272 }; 273 const char *class_name() { 274 return _class_name; 275 } 276 jobject jloader() { 277 return _jloader; 278 } 279 jobject protection_domain() { 280 return _protection_domain; 281 } 282 jclass class_being_redefined() { 283 return _class_being_redefined; 284 } 285 }; 286 287 ////////////////////////////////////////////////////////////////////////////// 288 289 int JvmtiExport::_field_access_count = 0; 290 int JvmtiExport::_field_modification_count = 0; 291 292 bool JvmtiExport::_can_access_local_variables = false; 293 bool JvmtiExport::_can_hotswap_or_post_breakpoint = false; 294 bool JvmtiExport::_can_modify_any_class = false; 295 bool JvmtiExport::_can_walk_any_space = false; 296 297 uint64_t JvmtiExport::_redefinition_count = 0; 298 bool JvmtiExport::_all_dependencies_are_recorded = false; 299 300 // 301 // field access management 302 // 303 304 // interpreter generator needs the address of the counter 305 address JvmtiExport::get_field_access_count_addr() { 306 // We don't grab a lock because we don't want to 307 // serialize field access between all threads. This means that a 308 // thread on another processor can see the wrong count value and 309 // may either miss making a needed call into post_field_access() 310 // or will make an unneeded call into post_field_access(). We pay 311 // this price to avoid slowing down the VM when we aren't watching 312 // field accesses. 313 // Other access/mutation safe by virtue of being in VM state. 314 return (address)(&_field_access_count); 315 } 316 317 // 318 // field modification management 319 // 320 321 // interpreter generator needs the address of the counter 322 address JvmtiExport::get_field_modification_count_addr() { 323 // We don't grab a lock because we don't 324 // want to serialize field modification between all threads. This 325 // means that a thread on another processor can see the wrong 326 // count value and may either miss making a needed call into 327 // post_field_modification() or will make an unneeded call into 328 // post_field_modification(). We pay this price to avoid slowing 329 // down the VM when we aren't watching field modifications. 330 // Other access/mutation safe by virtue of being in VM state. 331 return (address)(&_field_modification_count); 332 } 333 334 335 /////////////////////////////////////////////////////////////// 336 // Functions needed by java.lang.instrument for starting up javaagent. 337 /////////////////////////////////////////////////////////////// 338 339 jint 340 JvmtiExport::get_jvmti_interface(JavaVM *jvm, void **penv, jint version) { 341 // The JVMTI_VERSION_INTERFACE_JVMTI part of the version number 342 // has already been validated in JNI GetEnv(). 343 int major, minor, micro; 344 345 // micro version doesn't matter here (yet?) 346 decode_version_values(version, &major, &minor, µ); 347 switch (major) { 348 case 1: 349 switch (minor) { 350 case 0: // version 1.0.<micro> is recognized 351 case 1: // version 1.1.<micro> is recognized 352 case 2: // version 1.2.<micro> is recognized 353 break; 354 355 default: 356 return JNI_EVERSION; // unsupported minor version number 357 } 358 break; 359 case 9: 360 switch (minor) { 361 case 0: // version 9.0.<micro> is recognized 362 break; 363 default: 364 return JNI_EVERSION; // unsupported minor version number 365 } 366 break; 367 case 11: 368 switch (minor) { 369 case 0: // version 11.0.<micro> is recognized 370 break; 371 default: 372 return JNI_EVERSION; // unsupported minor version number 373 } 374 break; 375 default: 376 // Starting from 13 we do not care about minor version anymore 377 if (major < 13 || major > VM_Version::vm_major_version()) { 378 return JNI_EVERSION; // unsupported major version number 379 } 380 } 381 382 if (JvmtiEnv::get_phase() == JVMTI_PHASE_LIVE) { 383 JavaThread* current_thread = JavaThread::current(); 384 // transition code: native to VM 385 MACOS_AARCH64_ONLY(ThreadWXEnable __wx(WXWrite, current_thread)); 386 ThreadInVMfromNative __tiv(current_thread); 387 VM_ENTRY_BASE(jvmtiEnv*, JvmtiExport::get_jvmti_interface, current_thread) 388 debug_only(VMNativeEntryWrapper __vew;) 389 390 JvmtiEnv *jvmti_env = JvmtiEnv::create_a_jvmti(version); 391 *penv = jvmti_env->jvmti_external(); // actual type is jvmtiEnv* -- not to be confused with JvmtiEnv* 392 393 if (Continuations::enabled()) { 394 // Virtual threads support for agents loaded into running VM. 395 // There is a performance impact when VTMS transitions are enabled. 396 if (!JvmtiVTMSTransitionDisabler::VTMS_notify_jvmti_events()) { 397 JvmtiEnvBase::enable_virtual_threads_notify_jvmti(); 398 } 399 } 400 return JNI_OK; 401 402 } else if (JvmtiEnv::get_phase() == JVMTI_PHASE_ONLOAD) { 403 // not live, no thread to transition 404 JvmtiEnv *jvmti_env = JvmtiEnv::create_a_jvmti(version); 405 *penv = jvmti_env->jvmti_external(); // actual type is jvmtiEnv* -- not to be confused with JvmtiEnv* 406 407 if (Continuations::enabled()) { 408 // Virtual threads support for agents loaded at startup. 409 // There is a performance impact when VTMS transitions are enabled. 410 JvmtiVTMSTransitionDisabler::set_VTMS_notify_jvmti_events(true); 411 } 412 return JNI_OK; 413 414 } else { 415 // Called at the wrong time 416 *penv = nullptr; 417 return JNI_EDETACHED; 418 } 419 } 420 421 JvmtiThreadState* 422 JvmtiExport::get_jvmti_thread_state(JavaThread *thread) { 423 assert(thread == JavaThread::current(), "must be current thread"); 424 if (thread->is_vthread_mounted() && thread->jvmti_thread_state() == nullptr) { 425 JvmtiEventController::thread_started(thread); 426 } 427 return thread->jvmti_thread_state(); 428 } 429 430 void 431 JvmtiExport::add_default_read_edges(Handle h_module, TRAPS) { 432 if (!Universe::is_module_initialized()) { 433 return; // extra safety 434 } 435 assert(!h_module.is_null(), "module should always be set"); 436 437 // Invoke the transformedByAgent method 438 JavaValue result(T_VOID); 439 JavaCalls::call_static(&result, 440 vmClasses::module_Modules_klass(), 441 vmSymbols::transformedByAgent_name(), 442 vmSymbols::transformedByAgent_signature(), 443 h_module, 444 THREAD); 445 446 if (HAS_PENDING_EXCEPTION) { 447 LogTarget(Trace, jvmti) log; 448 LogStream log_stream(log); 449 java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream); 450 log_stream.cr(); 451 CLEAR_PENDING_EXCEPTION; 452 return; 453 } 454 } 455 456 jvmtiError 457 JvmtiExport::add_module_reads(Handle module, Handle to_module, TRAPS) { 458 if (!Universe::is_module_initialized()) { 459 return JVMTI_ERROR_NONE; // extra safety 460 } 461 assert(!module.is_null(), "module should always be set"); 462 assert(!to_module.is_null(), "to_module should always be set"); 463 464 // Invoke the addReads method 465 JavaValue result(T_VOID); 466 JavaCalls::call_static(&result, 467 vmClasses::module_Modules_klass(), 468 vmSymbols::addReads_name(), 469 vmSymbols::addReads_signature(), 470 module, 471 to_module, 472 THREAD); 473 474 if (HAS_PENDING_EXCEPTION) { 475 LogTarget(Trace, jvmti) log; 476 LogStream log_stream(log); 477 java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream); 478 log_stream.cr(); 479 CLEAR_PENDING_EXCEPTION; 480 return JVMTI_ERROR_INTERNAL; 481 } 482 return JVMTI_ERROR_NONE; 483 } 484 485 jvmtiError 486 JvmtiExport::add_module_exports(Handle module, Handle pkg_name, Handle to_module, TRAPS) { 487 if (!Universe::is_module_initialized()) { 488 return JVMTI_ERROR_NONE; // extra safety 489 } 490 assert(!module.is_null(), "module should always be set"); 491 assert(!to_module.is_null(), "to_module should always be set"); 492 assert(!pkg_name.is_null(), "pkg_name should always be set"); 493 494 // Invoke the addExports method 495 JavaValue result(T_VOID); 496 JavaCalls::call_static(&result, 497 vmClasses::module_Modules_klass(), 498 vmSymbols::addExports_name(), 499 vmSymbols::addExports_signature(), 500 module, 501 pkg_name, 502 to_module, 503 THREAD); 504 505 if (HAS_PENDING_EXCEPTION) { 506 Symbol* ex_name = PENDING_EXCEPTION->klass()->name(); 507 LogTarget(Trace, jvmti) log; 508 LogStream log_stream(log); 509 java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream); 510 log_stream.cr(); 511 CLEAR_PENDING_EXCEPTION; 512 if (ex_name == vmSymbols::java_lang_IllegalArgumentException()) { 513 return JVMTI_ERROR_ILLEGAL_ARGUMENT; 514 } 515 return JVMTI_ERROR_INTERNAL; 516 } 517 return JVMTI_ERROR_NONE; 518 } 519 520 jvmtiError 521 JvmtiExport::add_module_opens(Handle module, Handle pkg_name, Handle to_module, TRAPS) { 522 if (!Universe::is_module_initialized()) { 523 return JVMTI_ERROR_NONE; // extra safety 524 } 525 assert(!module.is_null(), "module should always be set"); 526 assert(!to_module.is_null(), "to_module should always be set"); 527 assert(!pkg_name.is_null(), "pkg_name should always be set"); 528 529 // Invoke the addOpens method 530 JavaValue result(T_VOID); 531 JavaCalls::call_static(&result, 532 vmClasses::module_Modules_klass(), 533 vmSymbols::addOpens_name(), 534 vmSymbols::addExports_signature(), 535 module, 536 pkg_name, 537 to_module, 538 THREAD); 539 540 if (HAS_PENDING_EXCEPTION) { 541 Symbol* ex_name = PENDING_EXCEPTION->klass()->name(); 542 LogTarget(Trace, jvmti) log; 543 LogStream log_stream(log); 544 java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream); 545 log_stream.cr(); 546 CLEAR_PENDING_EXCEPTION; 547 if (ex_name == vmSymbols::java_lang_IllegalArgumentException()) { 548 return JVMTI_ERROR_ILLEGAL_ARGUMENT; 549 } 550 return JVMTI_ERROR_INTERNAL; 551 } 552 return JVMTI_ERROR_NONE; 553 } 554 555 jvmtiError 556 JvmtiExport::add_module_uses(Handle module, Handle service, TRAPS) { 557 if (!Universe::is_module_initialized()) { 558 return JVMTI_ERROR_NONE; // extra safety 559 } 560 assert(!module.is_null(), "module should always be set"); 561 assert(!service.is_null(), "service should always be set"); 562 563 // Invoke the addUses method 564 JavaValue result(T_VOID); 565 JavaCalls::call_static(&result, 566 vmClasses::module_Modules_klass(), 567 vmSymbols::addUses_name(), 568 vmSymbols::addUses_signature(), 569 module, 570 service, 571 THREAD); 572 573 if (HAS_PENDING_EXCEPTION) { 574 LogTarget(Trace, jvmti) log; 575 LogStream log_stream(log); 576 java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream); 577 log_stream.cr(); 578 CLEAR_PENDING_EXCEPTION; 579 return JVMTI_ERROR_INTERNAL; 580 } 581 return JVMTI_ERROR_NONE; 582 } 583 584 jvmtiError 585 JvmtiExport::add_module_provides(Handle module, Handle service, Handle impl_class, TRAPS) { 586 if (!Universe::is_module_initialized()) { 587 return JVMTI_ERROR_NONE; // extra safety 588 } 589 assert(!module.is_null(), "module should always be set"); 590 assert(!service.is_null(), "service should always be set"); 591 assert(!impl_class.is_null(), "impl_class should always be set"); 592 593 // Invoke the addProvides method 594 JavaValue result(T_VOID); 595 JavaCalls::call_static(&result, 596 vmClasses::module_Modules_klass(), 597 vmSymbols::addProvides_name(), 598 vmSymbols::addProvides_signature(), 599 module, 600 service, 601 impl_class, 602 THREAD); 603 604 if (HAS_PENDING_EXCEPTION) { 605 LogTarget(Trace, jvmti) log; 606 LogStream log_stream(log); 607 java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream); 608 log_stream.cr(); 609 CLEAR_PENDING_EXCEPTION; 610 return JVMTI_ERROR_INTERNAL; 611 } 612 return JVMTI_ERROR_NONE; 613 } 614 615 void 616 JvmtiExport::decode_version_values(jint version, int * major, int * minor, 617 int * micro) { 618 *major = (version & JVMTI_VERSION_MASK_MAJOR) >> JVMTI_VERSION_SHIFT_MAJOR; 619 *minor = (version & JVMTI_VERSION_MASK_MINOR) >> JVMTI_VERSION_SHIFT_MINOR; 620 *micro = (version & JVMTI_VERSION_MASK_MICRO) >> JVMTI_VERSION_SHIFT_MICRO; 621 } 622 623 void JvmtiExport::enter_primordial_phase() { 624 JvmtiEnvBase::set_phase(JVMTI_PHASE_PRIMORDIAL); 625 } 626 627 void JvmtiExport::enter_early_start_phase() { 628 set_early_vmstart_recorded(true); 629 } 630 631 void JvmtiExport::enter_start_phase() { 632 JvmtiEnvBase::set_phase(JVMTI_PHASE_START); 633 } 634 635 void JvmtiExport::enter_onload_phase() { 636 JvmtiEnvBase::set_phase(JVMTI_PHASE_ONLOAD); 637 } 638 639 void JvmtiExport::enter_live_phase() { 640 JvmtiEnvBase::set_phase(JVMTI_PHASE_LIVE); 641 } 642 643 // 644 // JVMTI events that the VM posts to the debugger and also startup agent 645 // and call the agent's premain() for java.lang.instrument. 646 // 647 648 void JvmtiExport::post_early_vm_start() { 649 EVT_TRIG_TRACE(JVMTI_EVENT_VM_START, ("Trg Early VM start event triggered" )); 650 651 // can now enable some events 652 JvmtiEventController::vm_start(); 653 654 JvmtiEnvIterator it; 655 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 656 // Only early vmstart envs post early VMStart event 657 if (env->early_vmstart_env() && env->is_enabled(JVMTI_EVENT_VM_START)) { 658 EVT_TRACE(JVMTI_EVENT_VM_START, ("Evt Early VM start event sent" )); 659 JavaThread *thread = JavaThread::current(); 660 JvmtiThreadEventMark jem(thread); 661 JvmtiJavaThreadEventTransition jet(thread); 662 jvmtiEventVMStart callback = env->callbacks()->VMStart; 663 if (callback != nullptr) { 664 (*callback)(env->jvmti_external(), jem.jni_env()); 665 } 666 } 667 } 668 } 669 670 void JvmtiExport::post_vm_start() { 671 EVT_TRIG_TRACE(JVMTI_EVENT_VM_START, ("Trg VM start event triggered" )); 672 673 // can now enable some events 674 JvmtiEventController::vm_start(); 675 676 JvmtiEnvIterator it; 677 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 678 // Early vmstart envs do not post normal VMStart event 679 if (!env->early_vmstart_env() && env->is_enabled(JVMTI_EVENT_VM_START)) { 680 EVT_TRACE(JVMTI_EVENT_VM_START, ("Evt VM start event sent" )); 681 682 JavaThread *thread = JavaThread::current(); 683 JvmtiThreadEventMark jem(thread); 684 JvmtiJavaThreadEventTransition jet(thread); 685 jvmtiEventVMStart callback = env->callbacks()->VMStart; 686 if (callback != nullptr) { 687 (*callback)(env->jvmti_external(), jem.jni_env()); 688 } 689 } 690 } 691 } 692 693 static OopStorage* _jvmti_oop_storage = nullptr; 694 static OopStorage* _weak_tag_storage = nullptr; 695 696 OopStorage* JvmtiExport::jvmti_oop_storage() { 697 assert(_jvmti_oop_storage != nullptr, "not yet initialized"); 698 return _jvmti_oop_storage; 699 } 700 701 OopStorage* JvmtiExport::weak_tag_storage() { 702 assert(_weak_tag_storage != nullptr, "not yet initialized"); 703 return _weak_tag_storage; 704 } 705 706 void JvmtiExport::initialize_oop_storage() { 707 // OopStorage needs to be created early in startup and unconditionally 708 // because of OopStorageSet static array indices. 709 _jvmti_oop_storage = OopStorageSet::create_strong("JVMTI OopStorage", mtServiceability); 710 _weak_tag_storage = OopStorageSet::create_weak("JVMTI Tag Weak OopStorage", mtServiceability); 711 _weak_tag_storage->register_num_dead_callback(&JvmtiTagMap::gc_notification); 712 } 713 714 // Lookup an agent from an JvmtiEnv. Return agent only if it is not yet initialized. 715 // An agent can create multiple JvmtiEnvs, but for agent initialization, we are only interested in the initial one. 716 static JvmtiAgent* lookup_uninitialized_agent(JvmtiEnv* env, void* callback) { 717 JvmtiAgent* const agent = JvmtiAgentList::lookup(env, callback); 718 return agent == nullptr || agent->is_initialized() ? nullptr : agent; 719 } 720 721 void JvmtiExport::post_vm_initialized() { 722 EVT_TRIG_TRACE(JVMTI_EVENT_VM_INIT, ("Trg VM init event triggered" )); 723 724 // can now enable events 725 JvmtiEventController::vm_init(); 726 727 JvmtiEnvIterator it; 728 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 729 if (env->is_enabled(JVMTI_EVENT_VM_INIT)) { 730 EVT_TRACE(JVMTI_EVENT_VM_INIT, ("Evt VM init event sent" )); 731 732 JavaThread *thread = JavaThread::current(); 733 JvmtiThreadEventMark jem(thread); 734 JvmtiJavaThreadEventTransition jet(thread); 735 jvmtiEventVMInit callback = env->callbacks()->VMInit; 736 if (callback != nullptr) { 737 // We map the JvmtiEnv to its Agent to measure when and for how long 738 // it took to initialize so that JFR can report this information. 739 JvmtiAgent* const agent = lookup_uninitialized_agent(env, reinterpret_cast<void*>(callback)); 740 if (agent != nullptr) { 741 agent->initialization_begin(); 742 } 743 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread()); 744 if (agent != nullptr) { 745 agent->initialization_end(); 746 } 747 } 748 } 749 } 750 751 // Agents are initialized as part of posting the VMInit event above. 752 // For -Xrun agents and agents with no VMInit callback, we explicitly ensure they are also initialized. 753 // JVM_OnLoad and Agent_OnLoad callouts are performed too early for the proper timestamp logic. 754 JvmtiAgentList::initialize(); 755 } 756 757 void JvmtiExport::post_vm_death() { 758 EVT_TRIG_TRACE(JVMTI_EVENT_VM_DEATH, ("Trg VM death event triggered" )); 759 760 JvmtiTagMap::flush_all_object_free_events(); 761 762 JvmtiEnvIterator it; 763 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 764 if (env->is_enabled(JVMTI_EVENT_VM_DEATH)) { 765 EVT_TRACE(JVMTI_EVENT_VM_DEATH, ("Evt VM death event sent" )); 766 767 JavaThread *thread = JavaThread::current(); 768 JvmtiEventMark jem(thread); 769 JvmtiJavaThreadEventTransition jet(thread); 770 jvmtiEventVMDeath callback = env->callbacks()->VMDeath; 771 if (callback != nullptr) { 772 (*callback)(env->jvmti_external(), jem.jni_env()); 773 } 774 } 775 } 776 777 JvmtiEnvBase::set_phase(JVMTI_PHASE_DEAD); 778 JvmtiEventController::vm_death(); 779 } 780 781 char** 782 JvmtiExport::get_all_native_method_prefixes(int* count_ptr) { 783 // Have to grab JVMTI thread state lock to be sure environment doesn't 784 // go away while we iterate them. No locks during VM bring-up. 785 if (Threads::number_of_threads() == 0 || SafepointSynchronize::is_at_safepoint()) { 786 return JvmtiEnvBase::get_all_native_method_prefixes(count_ptr); 787 } else { 788 MutexLocker mu(JvmtiThreadState_lock); 789 return JvmtiEnvBase::get_all_native_method_prefixes(count_ptr); 790 } 791 } 792 793 // Convert an external thread reference to a JavaThread found on the 794 // specified ThreadsList. The ThreadsListHandle in the caller "protects" 795 // the returned JavaThread *. 796 // 797 // If thread_oop_p is not null, then the caller wants to use the oop 798 // after this call so the oop is returned. On success, *jt_pp is set 799 // to the converted JavaThread * and JVMTI_ERROR_NONE is returned. 800 // On error, returns various JVMTI_ERROR_* values. 801 // 802 jvmtiError 803 JvmtiExport::cv_external_thread_to_JavaThread(ThreadsList * t_list, 804 jthread thread, 805 JavaThread ** jt_pp, 806 oop * thread_oop_p) { 807 assert(t_list != nullptr, "must have a ThreadsList"); 808 assert(jt_pp != nullptr, "must have a return JavaThread pointer"); 809 // thread_oop_p is optional so no assert() 810 811 if (thread_oop_p != nullptr) { 812 *thread_oop_p = nullptr; 813 } 814 815 oop thread_oop = JNIHandles::resolve_external_guard(thread); 816 if (thread_oop == nullptr) { 817 // null jthread, GC'ed jthread or a bad JNI handle. 818 return JVMTI_ERROR_INVALID_THREAD; 819 } 820 // Looks like an oop at this point. 821 822 if (!thread_oop->is_a(vmClasses::Thread_klass())) { 823 // The oop is not a java.lang.Thread. 824 return JVMTI_ERROR_INVALID_THREAD; 825 } 826 // Looks like a java.lang.Thread oop at this point. 827 828 if (thread_oop_p != nullptr) { 829 // Return the oop to the caller; the caller may still want 830 // the oop even if this function returns an error. 831 *thread_oop_p = thread_oop; 832 } 833 834 JavaThread * java_thread = java_lang_Thread::thread(thread_oop); 835 if (java_thread == nullptr) { 836 if (java_lang_VirtualThread::is_instance(thread_oop)) { 837 return JVMTI_ERROR_INVALID_THREAD; 838 } 839 // The java.lang.Thread does not contain a JavaThread * so it has 840 // not yet run or it has died. 841 return JVMTI_ERROR_THREAD_NOT_ALIVE; 842 } 843 // Looks like a live JavaThread at this point. 844 845 if (!t_list->includes(java_thread)) { 846 // Not on the JavaThreads list so it is not alive. 847 return JVMTI_ERROR_THREAD_NOT_ALIVE; 848 } 849 850 // Return a live JavaThread that is "protected" by the 851 // ThreadsListHandle in the caller. 852 *jt_pp = java_thread; 853 854 return JVMTI_ERROR_NONE; 855 } 856 857 // Convert an oop to a JavaThread found on the specified ThreadsList. 858 // The ThreadsListHandle in the caller "protects" the returned 859 // JavaThread *. 860 // 861 // On success, *jt_pp is set to the converted JavaThread * and 862 // JVMTI_ERROR_NONE is returned. On error, returns various 863 // JVMTI_ERROR_* values. 864 // 865 jvmtiError 866 JvmtiExport::cv_oop_to_JavaThread(ThreadsList * t_list, oop thread_oop, 867 JavaThread ** jt_pp) { 868 assert(t_list != nullptr, "must have a ThreadsList"); 869 assert(thread_oop != nullptr, "must have an oop"); 870 assert(jt_pp != nullptr, "must have a return JavaThread pointer"); 871 872 if (!thread_oop->is_a(vmClasses::Thread_klass())) { 873 // The oop is not a java.lang.Thread. 874 return JVMTI_ERROR_INVALID_THREAD; 875 } 876 // Looks like a java.lang.Thread oop at this point. 877 878 JavaThread * java_thread = java_lang_Thread::thread(thread_oop); 879 if (java_thread == nullptr) { 880 // The java.lang.Thread does not contain a JavaThread * so it has 881 // not yet run or it has died. 882 return JVMTI_ERROR_THREAD_NOT_ALIVE; 883 } 884 // Looks like a live JavaThread at this point. 885 886 if (!t_list->includes(java_thread)) { 887 // Not on the JavaThreads list so it is not alive. 888 return JVMTI_ERROR_THREAD_NOT_ALIVE; 889 } 890 891 // Return a live JavaThread that is "protected" by the 892 // ThreadsListHandle in the caller. 893 *jt_pp = java_thread; 894 895 return JVMTI_ERROR_NONE; 896 } 897 898 class JvmtiClassFileLoadHookPoster : public StackObj { 899 private: 900 Symbol* _h_name; 901 Handle _class_loader; 902 Handle _h_protection_domain; 903 unsigned char ** _data_ptr; 904 unsigned char ** _end_ptr; 905 JavaThread * _thread; 906 jint _curr_len; 907 unsigned char * _curr_data; 908 JvmtiEnv * _curr_env; 909 JvmtiCachedClassFileData ** _cached_class_file_ptr; 910 JvmtiThreadState * _state; 911 Klass* _class_being_redefined; 912 JvmtiClassLoadKind _load_kind; 913 bool _has_been_modified; 914 915 public: 916 inline JvmtiClassFileLoadHookPoster(Symbol* h_name, Handle class_loader, 917 Handle h_protection_domain, 918 unsigned char **data_ptr, unsigned char **end_ptr, 919 JvmtiCachedClassFileData **cache_ptr) { 920 _h_name = h_name; 921 _class_loader = class_loader; 922 _h_protection_domain = h_protection_domain; 923 _data_ptr = data_ptr; 924 _end_ptr = end_ptr; 925 _thread = JavaThread::current(); 926 _curr_len = pointer_delta_as_int(*end_ptr, *data_ptr); 927 _curr_data = *data_ptr; 928 _curr_env = nullptr; 929 _cached_class_file_ptr = cache_ptr; 930 _has_been_modified = false; 931 932 assert(!_thread->is_in_any_VTMS_transition(), "CFLH events are not allowed in any VTMS transition"); 933 _state = JvmtiExport::get_jvmti_thread_state(_thread); 934 if (_state != nullptr) { 935 _class_being_redefined = _state->get_class_being_redefined(); 936 _load_kind = _state->get_class_load_kind(); 937 Klass* klass = (_class_being_redefined == nullptr) ? nullptr : _class_being_redefined; 938 if (_load_kind != jvmti_class_load_kind_load && klass != nullptr) { 939 ModuleEntry* module_entry = InstanceKlass::cast(klass)->module(); 940 assert(module_entry != nullptr, "module_entry should always be set"); 941 if (module_entry->is_named() && 942 module_entry->module() != nullptr && 943 !module_entry->has_default_read_edges()) { 944 if (!module_entry->set_has_default_read_edges()) { 945 // We won a potential race. 946 // Add read edges to the unnamed modules of the bootstrap and app class loaders 947 Handle class_module(_thread, module_entry->module()); // Obtain j.l.r.Module 948 JvmtiExport::add_default_read_edges(class_module, _thread); 949 } 950 } 951 } 952 // Clear class_being_redefined flag here. The action 953 // from agent handler could generate a new class file load 954 // hook event and if it is not cleared the new event generated 955 // from regular class file load could have this stale redefined 956 // class handle info. 957 _state->clear_class_being_redefined(); 958 } else { 959 // redefine and retransform will always set the thread state 960 _class_being_redefined = nullptr; 961 _load_kind = jvmti_class_load_kind_load; 962 } 963 } 964 965 void post() { 966 post_all_envs(); 967 copy_modified_data(); 968 } 969 970 bool has_been_modified() { return _has_been_modified; } 971 972 private: 973 void post_all_envs() { 974 if (_load_kind != jvmti_class_load_kind_retransform) { 975 // for class load and redefine, 976 // call the non-retransformable agents 977 JvmtiEnvIterator it; 978 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 979 if (!env->is_retransformable() && env->is_enabled(JVMTI_EVENT_CLASS_FILE_LOAD_HOOK)) { 980 // non-retransformable agents cannot retransform back, 981 // so no need to cache the original class file bytes 982 post_to_env(env, false); 983 } 984 } 985 } 986 JvmtiEnvIterator it; 987 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 988 // retransformable agents get all events 989 if (env->is_retransformable() && env->is_enabled(JVMTI_EVENT_CLASS_FILE_LOAD_HOOK)) { 990 // retransformable agents need to cache the original class file 991 // bytes if changes are made via the ClassFileLoadHook 992 post_to_env(env, true); 993 } 994 } 995 } 996 997 void post_to_env(JvmtiEnv* env, bool caching_needed) { 998 if (env->phase() == JVMTI_PHASE_PRIMORDIAL && !env->early_class_hook_env()) { 999 return; 1000 } 1001 unsigned char *new_data = nullptr; 1002 jint new_len = 0; 1003 JvmtiClassFileLoadEventMark jem(_thread, _h_name, _class_loader, 1004 _h_protection_domain, 1005 _class_being_redefined); 1006 JvmtiJavaThreadEventTransition jet(_thread); 1007 jvmtiEventClassFileLoadHook callback = env->callbacks()->ClassFileLoadHook; 1008 if (callback != nullptr) { 1009 (*callback)(env->jvmti_external(), jem.jni_env(), 1010 jem.class_being_redefined(), 1011 jem.jloader(), jem.class_name(), 1012 jem.protection_domain(), 1013 _curr_len, _curr_data, 1014 &new_len, &new_data); 1015 } 1016 if (new_data != nullptr) { 1017 // this agent has modified class data. 1018 _has_been_modified = true; 1019 if (caching_needed && *_cached_class_file_ptr == nullptr) { 1020 // data has been changed by the new retransformable agent 1021 // and it hasn't already been cached, cache it 1022 JvmtiCachedClassFileData *p; 1023 p = (JvmtiCachedClassFileData *)os::malloc( 1024 offset_of(JvmtiCachedClassFileData, data) + _curr_len, mtInternal); 1025 if (p == nullptr) { 1026 vm_exit_out_of_memory(offset_of(JvmtiCachedClassFileData, data) + _curr_len, 1027 OOM_MALLOC_ERROR, 1028 "unable to allocate cached copy of original class bytes"); 1029 } 1030 p->length = _curr_len; 1031 memcpy(p->data, _curr_data, _curr_len); 1032 *_cached_class_file_ptr = p; 1033 } 1034 1035 if (_curr_data != *_data_ptr) { 1036 // curr_data is previous agent modified class data. 1037 // And this has been changed by the new agent so 1038 // we can delete it now. 1039 _curr_env->Deallocate(_curr_data); 1040 } 1041 1042 // Class file data has changed by the current agent. 1043 _curr_data = new_data; 1044 _curr_len = new_len; 1045 // Save the current agent env we need this to deallocate the 1046 // memory allocated by this agent. 1047 _curr_env = env; 1048 } 1049 } 1050 1051 void copy_modified_data() { 1052 // if one of the agent has modified class file data. 1053 // Copy modified class data to new resources array. 1054 if (_curr_data != *_data_ptr) { 1055 *_data_ptr = NEW_RESOURCE_ARRAY(u1, _curr_len); 1056 memcpy(*_data_ptr, _curr_data, _curr_len); 1057 *_end_ptr = *_data_ptr + _curr_len; 1058 _curr_env->Deallocate(_curr_data); 1059 } 1060 } 1061 }; 1062 1063 bool JvmtiExport::is_early_phase() { 1064 return JvmtiEnvBase::get_phase() <= JVMTI_PHASE_PRIMORDIAL; 1065 } 1066 1067 bool JvmtiExport::has_early_class_hook_env() { 1068 JvmtiEnvIterator it; 1069 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 1070 if (env->early_class_hook_env()) { 1071 return true; 1072 } 1073 } 1074 return false; 1075 } 1076 1077 bool JvmtiExport::_should_post_class_file_load_hook = false; 1078 1079 // This flag is read by C2 during VM internal objects allocation 1080 int JvmtiExport::_should_notify_object_alloc = 0; 1081 1082 // this entry is for class file load hook on class load, redefine and retransform 1083 bool JvmtiExport::post_class_file_load_hook(Symbol* h_name, 1084 Handle class_loader, 1085 Handle h_protection_domain, 1086 unsigned char **data_ptr, 1087 unsigned char **end_ptr, 1088 JvmtiCachedClassFileData **cache_ptr) { 1089 if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { 1090 return false; 1091 } 1092 if (JavaThread::current()->is_in_tmp_VTMS_transition()) { 1093 return false; // skip CFLH events in tmp VTMS transition 1094 } 1095 1096 JvmtiClassFileLoadHookPoster poster(h_name, class_loader, 1097 h_protection_domain, 1098 data_ptr, end_ptr, 1099 cache_ptr); 1100 poster.post(); 1101 return poster.has_been_modified(); 1102 } 1103 1104 void JvmtiExport::report_unsupported(bool on) { 1105 // If any JVMTI service is turned on, we need to exit before native code 1106 // tries to access nonexistent services. 1107 if (on) { 1108 vm_exit_during_initialization("Java Kernel does not support JVMTI."); 1109 } 1110 } 1111 1112 1113 static inline Klass* oop_to_klass(oop obj) { 1114 Klass* k = obj->klass(); 1115 1116 // if the object is a java.lang.Class then return the java mirror 1117 if (k == vmClasses::Class_klass()) { 1118 if (!java_lang_Class::is_primitive(obj)) { 1119 k = java_lang_Class::as_Klass(obj); 1120 assert(k != nullptr, "class for non-primitive mirror must exist"); 1121 } 1122 } 1123 return k; 1124 } 1125 1126 class JvmtiObjectAllocEventMark : public JvmtiClassEventMark { 1127 private: 1128 jobject _jobj; 1129 jlong _size; 1130 public: 1131 JvmtiObjectAllocEventMark(JavaThread *thread, oop obj) : JvmtiClassEventMark(thread, oop_to_klass(obj)) { 1132 _jobj = (jobject)to_jobject(obj); 1133 _size = obj->size() * wordSize; 1134 }; 1135 jobject jni_jobject() { return _jobj; } 1136 jlong size() { return _size; } 1137 }; 1138 1139 class JvmtiCompiledMethodLoadEventMark : public JvmtiMethodEventMark { 1140 private: 1141 jint _code_size; 1142 const void *_code_data; 1143 jint _map_length; 1144 jvmtiAddrLocationMap *_map; 1145 const void *_compile_info; 1146 public: 1147 JvmtiCompiledMethodLoadEventMark(JavaThread *thread, nmethod *nm, void* compile_info_ptr = nullptr) 1148 : JvmtiMethodEventMark(thread,methodHandle(thread, nm->method())) { 1149 _code_data = nm->code_begin(); 1150 _code_size = nm->code_size(); 1151 _compile_info = compile_info_ptr; // Set void pointer of compiledMethodLoad Event. Default value is null. 1152 JvmtiCodeBlobEvents::build_jvmti_addr_location_map(nm, &_map, &_map_length); 1153 } 1154 ~JvmtiCompiledMethodLoadEventMark() { 1155 FREE_C_HEAP_ARRAY(jvmtiAddrLocationMap, _map); 1156 } 1157 1158 jint code_size() { return _code_size; } 1159 const void *code_data() { return _code_data; } 1160 jint map_length() { return _map_length; } 1161 const jvmtiAddrLocationMap* map() { return _map; } 1162 const void *compile_info() { return _compile_info; } 1163 }; 1164 1165 1166 1167 class JvmtiMonitorEventMark : public JvmtiVirtualThreadEventMark { 1168 private: 1169 jobject _jobj; 1170 public: 1171 JvmtiMonitorEventMark(JavaThread *thread, oop object) 1172 : JvmtiVirtualThreadEventMark(thread){ 1173 _jobj = to_jobject(object); 1174 } 1175 jobject jni_object() { return _jobj; } 1176 }; 1177 1178 /////////////////////////////////////////////////////////////// 1179 // 1180 // pending CompiledMethodUnload support 1181 // 1182 1183 void JvmtiExport::post_compiled_method_unload( 1184 jmethodID method, const void *code_begin) { 1185 if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { 1186 return; 1187 } 1188 JavaThread* thread = JavaThread::current(); 1189 EVT_TRIG_TRACE(JVMTI_EVENT_COMPILED_METHOD_UNLOAD, 1190 ("[%s] method compile unload event triggered", 1191 JvmtiTrace::safe_get_thread_name(thread))); 1192 1193 // post the event for each environment that has this event enabled. 1194 JvmtiEnvIterator it; 1195 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 1196 if (env->is_enabled(JVMTI_EVENT_COMPILED_METHOD_UNLOAD)) { 1197 if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { 1198 continue; 1199 } 1200 EVT_TRACE(JVMTI_EVENT_COMPILED_METHOD_UNLOAD, 1201 ("[%s] class compile method unload event sent jmethodID " PTR_FORMAT, 1202 JvmtiTrace::safe_get_thread_name(thread), p2i(method))); 1203 1204 ResourceMark rm(thread); 1205 1206 JvmtiEventMark jem(thread); 1207 JvmtiJavaThreadEventTransition jet(thread); 1208 jvmtiEventCompiledMethodUnload callback = env->callbacks()->CompiledMethodUnload; 1209 if (callback != nullptr) { 1210 (*callback)(env->jvmti_external(), method, code_begin); 1211 } 1212 } 1213 } 1214 } 1215 1216 /////////////////////////////////////////////////////////////// 1217 // 1218 // JvmtiExport 1219 // 1220 1221 void JvmtiExport::post_raw_breakpoint(JavaThread *thread, Method* method, address location) { 1222 HandleMark hm(thread); 1223 methodHandle mh(thread, method); 1224 1225 JvmtiThreadState *state = get_jvmti_thread_state(thread); 1226 if (state == nullptr) { 1227 return; 1228 } 1229 if (thread->is_in_any_VTMS_transition()) { 1230 return; // no events should be posted if thread is in any VTMS transition 1231 } 1232 1233 EVT_TRIG_TRACE(JVMTI_EVENT_BREAKPOINT, ("[%s] Trg Breakpoint triggered", 1234 JvmtiTrace::safe_get_thread_name(thread))); 1235 JvmtiEnvThreadStateIterator it(state); 1236 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 1237 ets->compare_and_set_current_location(mh(), location, JVMTI_EVENT_BREAKPOINT); 1238 if (!ets->breakpoint_posted() && ets->is_enabled(JVMTI_EVENT_BREAKPOINT)) { 1239 ThreadState old_os_state = thread->osthread()->get_state(); 1240 thread->osthread()->set_state(BREAKPOINTED); 1241 EVT_TRACE(JVMTI_EVENT_BREAKPOINT, ("[%s] Evt Breakpoint sent %s.%s @ " INTX_FORMAT, 1242 JvmtiTrace::safe_get_thread_name(thread), 1243 (mh() == nullptr) ? "null" : mh()->klass_name()->as_C_string(), 1244 (mh() == nullptr) ? "null" : mh()->name()->as_C_string(), 1245 location - mh()->code_base() )); 1246 1247 JvmtiEnv *env = ets->get_env(); 1248 JvmtiLocationEventMark jem(thread, mh, location); 1249 JvmtiJavaThreadEventTransition jet(thread); 1250 jvmtiEventBreakpoint callback = env->callbacks()->Breakpoint; 1251 if (callback != nullptr) { 1252 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), 1253 jem.jni_methodID(), jem.location()); 1254 } 1255 1256 ets->set_breakpoint_posted(); 1257 thread->osthread()->set_state(old_os_state); 1258 } 1259 } 1260 } 1261 1262 ////////////////////////////////////////////////////////////////////////////// 1263 1264 bool JvmtiExport::_can_get_source_debug_extension = false; 1265 bool JvmtiExport::_can_maintain_original_method_order = false; 1266 bool JvmtiExport::_can_post_interpreter_events = false; 1267 bool JvmtiExport::_can_post_on_exceptions = false; 1268 bool JvmtiExport::_can_post_breakpoint = false; 1269 bool JvmtiExport::_can_post_field_access = false; 1270 bool JvmtiExport::_can_post_field_modification = false; 1271 bool JvmtiExport::_can_post_method_entry = false; 1272 bool JvmtiExport::_can_post_method_exit = false; 1273 bool JvmtiExport::_can_post_frame_pop = false; 1274 bool JvmtiExport::_can_pop_frame = false; 1275 bool JvmtiExport::_can_force_early_return = false; 1276 bool JvmtiExport::_can_support_virtual_threads = false; 1277 bool JvmtiExport::_can_get_owned_monitor_info = false; 1278 1279 bool JvmtiExport::_early_vmstart_recorded = false; 1280 1281 bool JvmtiExport::_should_post_single_step = false; 1282 bool JvmtiExport::_should_post_field_access = false; 1283 bool JvmtiExport::_should_post_field_modification = false; 1284 bool JvmtiExport::_should_post_class_load = false; 1285 bool JvmtiExport::_should_post_class_prepare = false; 1286 bool JvmtiExport::_should_post_class_unload = false; 1287 bool JvmtiExport::_should_post_thread_life = false; 1288 bool JvmtiExport::_should_clean_up_heap_objects = false; 1289 bool JvmtiExport::_should_post_native_method_bind = false; 1290 bool JvmtiExport::_should_post_dynamic_code_generated = false; 1291 bool JvmtiExport::_should_post_data_dump = false; 1292 bool JvmtiExport::_should_post_compiled_method_load = false; 1293 bool JvmtiExport::_should_post_compiled_method_unload = false; 1294 bool JvmtiExport::_should_post_monitor_contended_enter = false; 1295 bool JvmtiExport::_should_post_monitor_contended_entered = false; 1296 bool JvmtiExport::_should_post_monitor_wait = false; 1297 bool JvmtiExport::_should_post_monitor_waited = false; 1298 bool JvmtiExport::_should_post_garbage_collection_start = false; 1299 bool JvmtiExport::_should_post_garbage_collection_finish = false; 1300 bool JvmtiExport::_should_post_object_free = false; 1301 bool JvmtiExport::_should_post_resource_exhausted = false; 1302 bool JvmtiExport::_should_post_vm_object_alloc = false; 1303 bool JvmtiExport::_should_post_sampled_object_alloc = false; 1304 bool JvmtiExport::_should_post_on_exceptions = false; 1305 bool JvmtiExport::_should_post_vthread_start = false; 1306 bool JvmtiExport::_should_post_vthread_end = false; 1307 bool JvmtiExport::_should_post_vthread_mount = false; 1308 bool JvmtiExport::_should_post_vthread_unmount = false; 1309 1310 //////////////////////////////////////////////////////////////////////////////////////////////// 1311 1312 1313 // 1314 // JVMTI single step management 1315 // 1316 void JvmtiExport::at_single_stepping_point(JavaThread *thread, Method* method, address location) { 1317 assert(JvmtiExport::should_post_single_step(), "must be single stepping"); 1318 1319 HandleMark hm(thread); 1320 methodHandle mh(thread, method); 1321 1322 // update information about current location and post a step event 1323 JvmtiThreadState *state = get_jvmti_thread_state(thread); 1324 if (state == nullptr) { 1325 return; 1326 } 1327 EVT_TRIG_TRACE(JVMTI_EVENT_SINGLE_STEP, ("[%s] Trg Single Step triggered", 1328 JvmtiTrace::safe_get_thread_name(thread))); 1329 if (!state->hide_single_stepping()) { 1330 if (state->is_pending_step_for_popframe()) { 1331 state->process_pending_step_for_popframe(); 1332 } 1333 if (state->is_pending_step_for_earlyret()) { 1334 state->process_pending_step_for_earlyret(); 1335 } 1336 JvmtiExport::post_single_step(thread, mh(), location); 1337 } 1338 } 1339 1340 1341 void JvmtiExport::expose_single_stepping(JavaThread *thread) { 1342 JvmtiThreadState *state = get_jvmti_thread_state(thread); 1343 if (state != nullptr) { 1344 state->clear_hide_single_stepping(); 1345 } 1346 } 1347 1348 1349 bool JvmtiExport::hide_single_stepping(JavaThread *thread) { 1350 JvmtiThreadState *state = get_jvmti_thread_state(thread); 1351 if (state != nullptr && state->is_enabled(JVMTI_EVENT_SINGLE_STEP)) { 1352 state->set_hide_single_stepping(); 1353 return true; 1354 } else { 1355 return false; 1356 } 1357 } 1358 1359 void JvmtiExport::post_class_load(JavaThread *thread, Klass* klass) { 1360 if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { 1361 return; 1362 } 1363 HandleMark hm(thread); 1364 1365 JvmtiThreadState *state = get_jvmti_thread_state(thread); 1366 if (state == nullptr) { 1367 return; 1368 } 1369 if (thread->is_in_any_VTMS_transition()) { 1370 return; // skip ClassLoad events in VTMS transition 1371 } 1372 1373 EVT_TRIG_TRACE(JVMTI_EVENT_CLASS_LOAD, ("[%s] Trg Class Load triggered", 1374 JvmtiTrace::safe_get_thread_name(thread))); 1375 JvmtiEnvThreadStateIterator it(state); 1376 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 1377 if (ets->is_enabled(JVMTI_EVENT_CLASS_LOAD)) { 1378 JvmtiEnv *env = ets->get_env(); 1379 if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { 1380 continue; 1381 } 1382 EVT_TRACE(JVMTI_EVENT_CLASS_LOAD, ("[%s] Evt Class Load sent %s", 1383 JvmtiTrace::safe_get_thread_name(thread), 1384 klass==nullptr? "null" : klass->external_name() )); 1385 JvmtiClassEventMark jem(thread, klass); 1386 JvmtiJavaThreadEventTransition jet(thread); 1387 jvmtiEventClassLoad callback = env->callbacks()->ClassLoad; 1388 if (callback != nullptr) { 1389 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_class()); 1390 } 1391 } 1392 } 1393 } 1394 1395 1396 void JvmtiExport::post_class_prepare(JavaThread *thread, Klass* klass) { 1397 if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { 1398 return; 1399 } 1400 HandleMark hm(thread); 1401 1402 JvmtiThreadState *state = get_jvmti_thread_state(thread); 1403 if (state == nullptr) { 1404 return; 1405 } 1406 if (thread->is_in_any_VTMS_transition()) { 1407 return; // skip ClassPrepare events in VTMS transition 1408 } 1409 1410 EVT_TRIG_TRACE(JVMTI_EVENT_CLASS_PREPARE, ("[%s] Trg Class Prepare triggered", 1411 JvmtiTrace::safe_get_thread_name(thread))); 1412 JvmtiEnvThreadStateIterator it(state); 1413 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 1414 if (ets->is_enabled(JVMTI_EVENT_CLASS_PREPARE)) { 1415 JvmtiEnv *env = ets->get_env(); 1416 if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { 1417 continue; 1418 } 1419 EVT_TRACE(JVMTI_EVENT_CLASS_PREPARE, ("[%s] Evt Class Prepare sent %s", 1420 JvmtiTrace::safe_get_thread_name(thread), 1421 klass==nullptr? "null" : klass->external_name() )); 1422 JvmtiClassEventMark jem(thread, klass); 1423 JvmtiJavaThreadEventTransition jet(thread); 1424 jvmtiEventClassPrepare callback = env->callbacks()->ClassPrepare; 1425 if (callback != nullptr) { 1426 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_class()); 1427 } 1428 } 1429 } 1430 } 1431 1432 void JvmtiExport::post_class_unload(Klass* klass) { 1433 if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { 1434 return; 1435 } 1436 1437 // postings to the service thread so that it can perform them in a safe 1438 // context and in-order. 1439 ResourceMark rm; 1440 // JvmtiDeferredEvent copies the string. 1441 JvmtiDeferredEvent event = JvmtiDeferredEvent::class_unload_event(klass->name()->as_C_string()); 1442 ServiceThread::enqueue_deferred_event(&event); 1443 } 1444 1445 1446 void JvmtiExport::post_class_unload_internal(const char* name) { 1447 if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { 1448 return; 1449 } 1450 assert(Thread::current()->is_service_thread(), "must be called from ServiceThread"); 1451 JavaThread *thread = JavaThread::current(); 1452 HandleMark hm(thread); 1453 1454 EVT_TRIG_TRACE(EXT_EVENT_CLASS_UNLOAD, ("[?] Trg Class Unload triggered" )); 1455 if (JvmtiEventController::is_enabled((jvmtiEvent)EXT_EVENT_CLASS_UNLOAD)) { 1456 1457 JvmtiEnvIterator it; 1458 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 1459 if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { 1460 continue; 1461 } 1462 if (env->is_enabled((jvmtiEvent)EXT_EVENT_CLASS_UNLOAD)) { 1463 EVT_TRACE(EXT_EVENT_CLASS_UNLOAD, ("[?] Evt Class Unload sent %s", name)); 1464 1465 JvmtiEventMark jem(thread); 1466 JvmtiJavaThreadEventTransition jet(thread); 1467 jvmtiExtensionEvent callback = env->ext_callbacks()->ClassUnload; 1468 if (callback != nullptr) { 1469 (*callback)(env->jvmti_external(), jem.jni_env(), name); 1470 } 1471 } 1472 } 1473 } 1474 } 1475 1476 1477 void JvmtiExport::post_thread_start(JavaThread *thread) { 1478 if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { 1479 return; 1480 } 1481 assert(thread->thread_state() == _thread_in_vm, "must be in vm state"); 1482 1483 EVT_TRIG_TRACE(JVMTI_EVENT_THREAD_START, ("[%s] Trg Thread Start event triggered", 1484 JvmtiTrace::safe_get_thread_name(thread))); 1485 1486 // do JVMTI thread initialization (if needed) 1487 JvmtiEventController::thread_started(thread); 1488 1489 if (thread->threadObj()->is_a(vmClasses::BoundVirtualThread_klass())) { 1490 if (JvmtiExport::can_support_virtual_threads()) { 1491 // Check for VirtualThreadStart event instead. 1492 HandleMark hm(thread); 1493 Handle vthread(thread, thread->threadObj()); 1494 JvmtiExport::post_vthread_start((jthread)vthread.raw_value()); 1495 } 1496 return; 1497 } 1498 1499 // Do not post thread start event for hidden java thread. 1500 if (JvmtiEventController::is_enabled(JVMTI_EVENT_THREAD_START) && 1501 !thread->is_hidden_from_external_view()) { 1502 JvmtiEnvIterator it; 1503 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 1504 if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { 1505 continue; 1506 } 1507 if (env->is_enabled(JVMTI_EVENT_THREAD_START)) { 1508 EVT_TRACE(JVMTI_EVENT_THREAD_START, ("[%s] Evt Thread Start event sent", 1509 JvmtiTrace::safe_get_thread_name(thread) )); 1510 1511 JvmtiVirtualThreadEventMark jem(thread); 1512 JvmtiJavaThreadEventTransition jet(thread); 1513 jvmtiEventThreadStart callback = env->callbacks()->ThreadStart; 1514 if (callback != nullptr) { 1515 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread()); 1516 } 1517 } 1518 } 1519 } 1520 } 1521 1522 1523 void JvmtiExport::post_thread_end(JavaThread *thread) { 1524 if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { 1525 return; 1526 } 1527 EVT_TRIG_TRACE(JVMTI_EVENT_THREAD_END, ("[%s] Trg Thread End event triggered", 1528 JvmtiTrace::safe_get_thread_name(thread))); 1529 1530 JvmtiThreadState *state = get_jvmti_thread_state(thread); 1531 if (state == nullptr) { 1532 return; 1533 } 1534 1535 if (thread->threadObj()->is_a(vmClasses::BoundVirtualThread_klass())) { 1536 if (JvmtiExport::can_support_virtual_threads()) { 1537 // Check for VirtualThreadEnd event instead. 1538 HandleMark hm(thread); 1539 Handle vthread(thread, thread->threadObj()); 1540 JvmtiExport::post_vthread_end((jthread)vthread.raw_value()); 1541 } 1542 return; 1543 } 1544 1545 // Do not post thread end event for hidden java thread. 1546 if (state->is_enabled(JVMTI_EVENT_THREAD_END) && 1547 !thread->is_hidden_from_external_view()) { 1548 1549 JvmtiEnvThreadStateIterator it(state); 1550 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 1551 JvmtiEnv *env = ets->get_env(); 1552 if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { 1553 continue; 1554 } 1555 if (ets->is_enabled(JVMTI_EVENT_THREAD_END)) { 1556 EVT_TRACE(JVMTI_EVENT_THREAD_END, ("[%s] Evt Thread End event sent", 1557 JvmtiTrace::safe_get_thread_name(thread) )); 1558 1559 JvmtiVirtualThreadEventMark jem(thread); 1560 JvmtiJavaThreadEventTransition jet(thread); 1561 jvmtiEventThreadEnd callback = env->callbacks()->ThreadEnd; 1562 if (callback != nullptr) { 1563 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread()); 1564 } 1565 } 1566 } 1567 } 1568 } 1569 1570 1571 void JvmtiExport::post_vthread_start(jobject vthread) { 1572 if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { 1573 return; 1574 } 1575 EVT_TRIG_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_START, ("[%p] Trg Virtual Thread Start event triggered", vthread)); 1576 1577 JavaThread *thread = JavaThread::current(); 1578 assert(!thread->is_hidden_from_external_view(), "carrier threads can't be hidden"); 1579 1580 if (JvmtiEventController::is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_START)) { 1581 JvmtiEnvIterator it; 1582 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 1583 if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { 1584 continue; 1585 } 1586 if (env->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_START)) { 1587 EVT_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_START, ("[%p] Evt Virtual Thread Start event sent", vthread)); 1588 1589 JvmtiVirtualThreadEventMark jem(thread); 1590 JvmtiJavaThreadEventTransition jet(thread); 1591 jvmtiEventVirtualThreadStart callback = env->callbacks()->VirtualThreadStart; 1592 if (callback != nullptr) { 1593 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread()); 1594 } 1595 } 1596 } 1597 } 1598 } 1599 1600 void JvmtiExport::post_vthread_end(jobject vthread) { 1601 if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { 1602 return; 1603 } 1604 EVT_TRIG_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_END, ("[%p] Trg Virtual Thread End event triggered", vthread)); 1605 1606 JavaThread *thread = JavaThread::current(); 1607 assert(!thread->is_hidden_from_external_view(), "carrier threads can't be hidden"); 1608 1609 JvmtiThreadState *state = get_jvmti_thread_state(thread); 1610 if (state == nullptr) { 1611 return; 1612 } 1613 1614 if (state->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_END)) { 1615 JvmtiEnvThreadStateIterator it(state); 1616 1617 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 1618 JvmtiEnv *env = ets->get_env(); 1619 if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { 1620 continue; 1621 } 1622 if (ets->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_END)) { 1623 EVT_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_END, ("[%p] Evt Virtual Thread End event sent", vthread)); 1624 1625 JvmtiVirtualThreadEventMark jem(thread); 1626 JvmtiJavaThreadEventTransition jet(thread); 1627 jvmtiEventVirtualThreadEnd callback = env->callbacks()->VirtualThreadEnd; 1628 if (callback != nullptr) { 1629 (*callback)(env->jvmti_external(), jem.jni_env(), vthread); 1630 } 1631 } 1632 } 1633 } 1634 } 1635 1636 void JvmtiExport::post_vthread_mount(jobject vthread) { 1637 if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { 1638 return; 1639 } 1640 JavaThread *thread = JavaThread::current(); 1641 HandleMark hm(thread); 1642 EVT_TRIG_TRACE(EXT_EVENT_VIRTUAL_THREAD_MOUNT, ("[%p] Trg Virtual Thread Mount event triggered", vthread)); 1643 1644 JvmtiThreadState *state = get_jvmti_thread_state(thread); 1645 if (state == nullptr) { 1646 return; 1647 } 1648 1649 if (state->is_enabled((jvmtiEvent)EXT_EVENT_VIRTUAL_THREAD_MOUNT)) { 1650 JvmtiEnvThreadStateIterator it(state); 1651 1652 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 1653 JvmtiEnv *env = ets->get_env(); 1654 if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { 1655 continue; 1656 } 1657 if (ets->is_enabled((jvmtiEvent)EXT_EVENT_VIRTUAL_THREAD_MOUNT)) { 1658 EVT_TRACE(EXT_EVENT_VIRTUAL_THREAD_MOUNT, ("[%p] Evt Virtual Thread Mount event sent", vthread)); 1659 1660 JvmtiVirtualThreadEventMark jem(thread); 1661 JvmtiJavaThreadEventTransition jet(thread); 1662 jvmtiExtensionEvent callback = env->ext_callbacks()->VirtualThreadMount; 1663 if (callback != nullptr) { 1664 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread()); 1665 } 1666 } 1667 } 1668 } 1669 } 1670 1671 void JvmtiExport::post_vthread_unmount(jobject vthread) { 1672 if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { 1673 return; 1674 } 1675 JavaThread *thread = JavaThread::current(); 1676 HandleMark hm(thread); 1677 EVT_TRIG_TRACE(EXT_EVENT_VIRTUAL_THREAD_UNMOUNT, ("[%p] Trg Virtual Thread Unmount event triggered", vthread)); 1678 1679 // On preemption JVMTI state rebinding has already happened so get it always direclty from the oop. 1680 JvmtiThreadState *state = java_lang_Thread::jvmti_thread_state(JNIHandles::resolve(vthread)); 1681 if (state == NULL) { 1682 return; 1683 } 1684 1685 if (state->is_enabled((jvmtiEvent)EXT_EVENT_VIRTUAL_THREAD_UNMOUNT)) { 1686 JvmtiEnvThreadStateIterator it(state); 1687 1688 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 1689 JvmtiEnv *env = ets->get_env(); 1690 if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { 1691 continue; 1692 } 1693 if (ets->is_enabled((jvmtiEvent)EXT_EVENT_VIRTUAL_THREAD_UNMOUNT)) { 1694 EVT_TRACE(EXT_EVENT_VIRTUAL_THREAD_UNMOUNT, ("[%p] Evt Virtual Thread Unmount event sent", vthread)); 1695 1696 JvmtiVirtualThreadEventMark jem(thread); 1697 JvmtiJavaThreadEventTransition jet(thread); 1698 jvmtiExtensionEvent callback = env->ext_callbacks()->VirtualThreadUnmount; 1699 if (callback != nullptr) { 1700 (*callback)(env->jvmti_external(), jem.jni_env(), vthread); 1701 } 1702 } 1703 } 1704 } 1705 } 1706 1707 void JvmtiExport::continuation_yield_cleanup(JavaThread* thread, jint continuation_frame_count) { 1708 if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { 1709 return; 1710 } 1711 1712 assert(thread == JavaThread::current(), "must be"); 1713 JvmtiThreadState *state = get_jvmti_thread_state(thread); 1714 if (state == nullptr) { 1715 return; 1716 } 1717 state->invalidate_cur_stack_depth(); 1718 1719 // Clear frame_pop requests in frames popped by yield 1720 if (can_post_frame_pop()) { 1721 JvmtiEnvThreadStateIterator it(state); 1722 int top_frame_num = state->cur_stack_depth() + continuation_frame_count; 1723 1724 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 1725 if (!ets->has_frame_pops()) { 1726 continue; 1727 } 1728 for (int frame_idx = 0; frame_idx < continuation_frame_count; frame_idx++) { 1729 int frame_num = top_frame_num - frame_idx; 1730 1731 if (!state->is_virtual() && ets->is_frame_pop(frame_num)) { 1732 // remove the frame's entry 1733 MutexLocker mu(JvmtiThreadState_lock); 1734 ets->clear_frame_pop(frame_num); 1735 } 1736 } 1737 } 1738 } 1739 } 1740 1741 void JvmtiExport::post_object_free(JvmtiEnv* env, GrowableArray<jlong>* objects) { 1742 assert(objects != nullptr, "Nothing to post"); 1743 1744 JavaThread *javaThread = JavaThread::current(); 1745 if (javaThread->is_in_any_VTMS_transition()) { 1746 return; // no events should be posted if thread is in any VTMS transition 1747 } 1748 if (!env->is_enabled(JVMTI_EVENT_OBJECT_FREE)) { 1749 return; // the event type has been already disabled 1750 } 1751 1752 EVT_TRIG_TRACE(JVMTI_EVENT_OBJECT_FREE, ("[?] Trg Object Free triggered" )); 1753 EVT_TRACE(JVMTI_EVENT_OBJECT_FREE, ("[?] Evt Object Free sent")); 1754 1755 JvmtiThreadEventMark jem(javaThread); 1756 JvmtiJavaThreadEventTransition jet(javaThread); 1757 jvmtiEventObjectFree callback = env->callbacks()->ObjectFree; 1758 if (callback != nullptr) { 1759 for (int index = 0; index < objects->length(); index++) { 1760 (*callback)(env->jvmti_external(), objects->at(index)); 1761 } 1762 } 1763 } 1764 1765 void JvmtiExport::post_resource_exhausted(jint resource_exhausted_flags, const char* description) { 1766 1767 JavaThread *thread = JavaThread::current(); 1768 1769 if (thread->is_in_any_VTMS_transition()) { 1770 return; // no events should be posted if thread is in any VTMS transition 1771 } 1772 1773 log_error(jvmti)("Posting Resource Exhausted event: %s", 1774 description != nullptr ? description : "unknown"); 1775 1776 // JDK-8213834: handlers of ResourceExhausted may attempt some analysis 1777 // which often requires running java. 1778 // This will cause problems on threads not able to run java, e.g. compiler 1779 // threads. To forestall these problems, we therefore suppress sending this 1780 // event from threads which are not able to run java. 1781 if (!thread->can_call_java()) { 1782 return; 1783 } 1784 1785 EVT_TRIG_TRACE(JVMTI_EVENT_RESOURCE_EXHAUSTED, ("Trg resource exhausted event triggered" )); 1786 1787 JvmtiEnvIterator it; 1788 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 1789 if (env->is_enabled(JVMTI_EVENT_RESOURCE_EXHAUSTED)) { 1790 EVT_TRACE(JVMTI_EVENT_RESOURCE_EXHAUSTED, ("Evt resource exhausted event sent" )); 1791 1792 JvmtiThreadEventMark jem(thread); 1793 JvmtiJavaThreadEventTransition jet(thread); 1794 jvmtiEventResourceExhausted callback = env->callbacks()->ResourceExhausted; 1795 if (callback != nullptr) { 1796 (*callback)(env->jvmti_external(), jem.jni_env(), 1797 resource_exhausted_flags, nullptr, description); 1798 } 1799 } 1800 } 1801 } 1802 1803 void JvmtiExport::post_method_entry(JavaThread *thread, Method* method, frame current_frame) { 1804 HandleMark hm(thread); 1805 methodHandle mh(thread, method); 1806 1807 JvmtiThreadState *state = get_jvmti_thread_state(thread); 1808 if (state == nullptr || !state->is_interp_only_mode()) { 1809 // for any thread that actually wants method entry, interp_only_mode is set 1810 return; 1811 } 1812 if (mh->jvmti_mount_transition() || thread->is_in_any_VTMS_transition()) { 1813 return; // no events should be posted if thread is in any VTMS transition 1814 } 1815 EVT_TRIG_TRACE(JVMTI_EVENT_METHOD_ENTRY, ("[%s] Trg Method Entry triggered %s.%s", 1816 JvmtiTrace::safe_get_thread_name(thread), 1817 (mh() == nullptr) ? "null" : mh()->klass_name()->as_C_string(), 1818 (mh() == nullptr) ? "null" : mh()->name()->as_C_string() )); 1819 1820 state->incr_cur_stack_depth(); 1821 1822 if (state->is_enabled(JVMTI_EVENT_METHOD_ENTRY)) { 1823 JvmtiEnvThreadStateIterator it(state); 1824 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 1825 if (ets->is_enabled(JVMTI_EVENT_METHOD_ENTRY)) { 1826 EVT_TRACE(JVMTI_EVENT_METHOD_ENTRY, ("[%s] Evt Method Entry sent %s.%s", 1827 JvmtiTrace::safe_get_thread_name(thread), 1828 (mh() == nullptr) ? "null" : mh()->klass_name()->as_C_string(), 1829 (mh() == nullptr) ? "null" : mh()->name()->as_C_string() )); 1830 1831 JvmtiEnv *env = ets->get_env(); 1832 JvmtiMethodEventMark jem(thread, mh); 1833 JvmtiJavaThreadEventTransition jet(thread); 1834 jvmtiEventMethodEntry callback = env->callbacks()->MethodEntry; 1835 if (callback != nullptr) { 1836 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_methodID()); 1837 } 1838 } 1839 } 1840 } 1841 } 1842 1843 void JvmtiExport::post_method_exit(JavaThread* thread, Method* method, frame current_frame) { 1844 HandleMark hm(thread); 1845 methodHandle mh(thread, method); 1846 1847 JvmtiThreadState *state = get_jvmti_thread_state(thread); 1848 1849 if (state == nullptr || !state->is_interp_only_mode()) { 1850 // for any thread that actually wants method exit, interp_only_mode is set 1851 return; 1852 } 1853 1854 // return a flag when a method terminates by throwing an exception 1855 // i.e. if an exception is thrown and it's not caught by the current method 1856 bool exception_exit = state->is_exception_detected() && !state->is_exception_caught(); 1857 Handle result; 1858 jvalue value; 1859 value.j = 0L; 1860 1861 if (state->is_enabled(JVMTI_EVENT_METHOD_EXIT)) { 1862 // if the method hasn't been popped because of an exception then we populate 1863 // the return_value parameter for the callback. At this point we only have 1864 // the address of a "raw result" and we just call into the interpreter to 1865 // convert this into a jvalue. 1866 if (!exception_exit) { 1867 oop oop_result; 1868 BasicType type = current_frame.interpreter_frame_result(&oop_result, &value); 1869 if (is_reference_type(type)) { 1870 result = Handle(thread, oop_result); 1871 value.l = JNIHandles::make_local(thread, result()); 1872 } 1873 } 1874 } 1875 1876 // Deferred transition to VM, so we can stash away the return oop before GC 1877 // Note that this transition is not needed when throwing an exception, because 1878 // there is no oop to retain. 1879 JavaThread* current = thread; // for JRT_BLOCK 1880 JRT_BLOCK 1881 post_method_exit_inner(thread, mh, state, exception_exit, current_frame, value); 1882 JRT_BLOCK_END 1883 1884 if (result.not_null() && !mh->is_native()) { 1885 // We have to restore the oop on the stack for interpreter frames 1886 *(oop*)current_frame.interpreter_frame_tos_address() = result(); 1887 } 1888 } 1889 1890 void JvmtiExport::post_method_exit_inner(JavaThread* thread, 1891 methodHandle& mh, 1892 JvmtiThreadState *state, 1893 bool exception_exit, 1894 frame current_frame, 1895 jvalue& value) { 1896 if (mh->jvmti_mount_transition() || thread->is_in_any_VTMS_transition()) { 1897 return; // no events should be posted if thread is in any VTMS transition 1898 } 1899 1900 EVT_TRIG_TRACE(JVMTI_EVENT_METHOD_EXIT, ("[%s] Trg Method Exit triggered %s.%s", 1901 JvmtiTrace::safe_get_thread_name(thread), 1902 (mh() == nullptr) ? "null" : mh()->klass_name()->as_C_string(), 1903 (mh() == nullptr) ? "null" : mh()->name()->as_C_string() )); 1904 1905 if (state->is_enabled(JVMTI_EVENT_METHOD_EXIT)) { 1906 JvmtiEnvThreadStateIterator it(state); 1907 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 1908 if (ets->is_enabled(JVMTI_EVENT_METHOD_EXIT)) { 1909 EVT_TRACE(JVMTI_EVENT_METHOD_EXIT, ("[%s] Evt Method Exit sent %s.%s", 1910 JvmtiTrace::safe_get_thread_name(thread), 1911 (mh() == nullptr) ? "null" : mh()->klass_name()->as_C_string(), 1912 (mh() == nullptr) ? "null" : mh()->name()->as_C_string() )); 1913 1914 JvmtiEnv *env = ets->get_env(); 1915 JvmtiMethodEventMark jem(thread, mh); 1916 JvmtiJavaThreadEventTransition jet(thread); 1917 jvmtiEventMethodExit callback = env->callbacks()->MethodExit; 1918 if (callback != nullptr) { 1919 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), 1920 jem.jni_methodID(), exception_exit, value); 1921 } 1922 } 1923 } 1924 } 1925 1926 JvmtiEnvThreadStateIterator it(state); 1927 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 1928 if (ets->has_frame_pops()) { 1929 int cur_frame_number = state->cur_stack_depth(); 1930 1931 if (ets->is_frame_pop(cur_frame_number)) { 1932 // we have a NotifyFramePop entry for this frame. 1933 // now check that this env/thread wants this event 1934 if (ets->is_enabled(JVMTI_EVENT_FRAME_POP)) { 1935 EVT_TRACE(JVMTI_EVENT_FRAME_POP, ("[%s] Evt Frame Pop sent %s.%s", 1936 JvmtiTrace::safe_get_thread_name(thread), 1937 (mh() == nullptr) ? "null" : mh()->klass_name()->as_C_string(), 1938 (mh() == nullptr) ? "null" : mh()->name()->as_C_string() )); 1939 1940 // we also need to issue a frame pop event for this frame 1941 JvmtiEnv *env = ets->get_env(); 1942 JvmtiMethodEventMark jem(thread, mh); 1943 JvmtiJavaThreadEventTransition jet(thread); 1944 jvmtiEventFramePop callback = env->callbacks()->FramePop; 1945 if (callback != nullptr) { 1946 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), 1947 jem.jni_methodID(), exception_exit); 1948 } 1949 } 1950 // remove the frame's entry 1951 { 1952 MutexLocker mu(JvmtiThreadState_lock); 1953 ets->clear_frame_pop(cur_frame_number); 1954 } 1955 } 1956 } 1957 } 1958 1959 state->decr_cur_stack_depth(); 1960 } 1961 1962 1963 // Todo: inline this for optimization 1964 void JvmtiExport::post_single_step(JavaThread *thread, Method* method, address location) { 1965 HandleMark hm(thread); 1966 methodHandle mh(thread, method); 1967 1968 JvmtiThreadState *state = get_jvmti_thread_state(thread); 1969 if (state == nullptr) { 1970 return; 1971 } 1972 if (mh->jvmti_mount_transition() || thread->is_in_any_VTMS_transition()) { 1973 return; // no events should be posted if thread is in any VTMS transition 1974 } 1975 1976 JvmtiEnvThreadStateIterator it(state); 1977 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 1978 ets->compare_and_set_current_location(mh(), location, JVMTI_EVENT_SINGLE_STEP); 1979 if (!ets->single_stepping_posted() && ets->is_enabled(JVMTI_EVENT_SINGLE_STEP)) { 1980 EVT_TRACE(JVMTI_EVENT_SINGLE_STEP, ("[%s] Evt Single Step sent %s.%s @ " INTX_FORMAT, 1981 JvmtiTrace::safe_get_thread_name(thread), 1982 (mh() == nullptr) ? "null" : mh()->klass_name()->as_C_string(), 1983 (mh() == nullptr) ? "null" : mh()->name()->as_C_string(), 1984 location - mh()->code_base() )); 1985 1986 JvmtiEnv *env = ets->get_env(); 1987 JvmtiLocationEventMark jem(thread, mh, location); 1988 JvmtiJavaThreadEventTransition jet(thread); 1989 jvmtiEventSingleStep callback = env->callbacks()->SingleStep; 1990 if (callback != nullptr) { 1991 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), 1992 jem.jni_methodID(), jem.location()); 1993 } 1994 1995 ets->set_single_stepping_posted(); 1996 } 1997 } 1998 } 1999 2000 void JvmtiExport::post_exception_throw(JavaThread *thread, Method* method, address location, oop exception) { 2001 HandleMark hm(thread); 2002 methodHandle mh(thread, method); 2003 Handle exception_handle(thread, exception); 2004 // The KeepStackGCProcessedMark below keeps the target thread and its stack fully 2005 // GC processed across this scope. This is needed because there is a stack walk 2006 // below with safepoint polls inside of it. After such safepoints, we have to 2007 // ensure the stack is sufficiently processed. 2008 KeepStackGCProcessedMark ksgcpm(thread); 2009 2010 JvmtiThreadState *state = get_jvmti_thread_state(thread); 2011 if (state == nullptr) { 2012 return; 2013 } 2014 if (thread->is_in_any_VTMS_transition()) { 2015 return; // no events should be posted if thread is in any VTMS transition 2016 } 2017 2018 EVT_TRIG_TRACE(JVMTI_EVENT_EXCEPTION, ("[%s] Trg Exception thrown triggered", 2019 JvmtiTrace::safe_get_thread_name(thread))); 2020 if (!state->is_exception_detected()) { 2021 state->set_exception_detected(); 2022 JvmtiEnvThreadStateIterator it(state); 2023 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 2024 if (ets->is_enabled(JVMTI_EVENT_EXCEPTION) && (exception != nullptr)) { 2025 2026 EVT_TRACE(JVMTI_EVENT_EXCEPTION, 2027 ("[%s] Evt Exception thrown sent %s.%s @ " INTX_FORMAT, 2028 JvmtiTrace::safe_get_thread_name(thread), 2029 (mh() == nullptr) ? "null" : mh()->klass_name()->as_C_string(), 2030 (mh() == nullptr) ? "null" : mh()->name()->as_C_string(), 2031 location - mh()->code_base() )); 2032 2033 JvmtiEnv *env = ets->get_env(); 2034 JvmtiExceptionEventMark jem(thread, mh, location, exception_handle); 2035 2036 // It's okay to clear these exceptions here because we duplicate 2037 // this lookup in InterpreterRuntime::exception_handler_for_exception. 2038 EXCEPTION_MARK; 2039 2040 bool should_repeat; 2041 vframeStream st(thread); 2042 assert(!st.at_end(), "cannot be at end"); 2043 Method* current_method = nullptr; 2044 // A GC may occur during the Method::fast_exception_handler_bci_for() 2045 // call below if it needs to load the constraint class. Using a 2046 // methodHandle to keep the 'current_method' from being deallocated 2047 // if GC happens. 2048 methodHandle current_mh = methodHandle(thread, current_method); 2049 int current_bci = -1; 2050 do { 2051 current_method = st.method(); 2052 current_mh = methodHandle(thread, current_method); 2053 current_bci = st.bci(); 2054 do { 2055 should_repeat = false; 2056 Klass* eh_klass = exception_handle()->klass(); 2057 current_bci = Method::fast_exception_handler_bci_for( 2058 current_mh, eh_klass, current_bci, THREAD); 2059 if (HAS_PENDING_EXCEPTION) { 2060 exception_handle = Handle(thread, PENDING_EXCEPTION); 2061 CLEAR_PENDING_EXCEPTION; 2062 should_repeat = true; 2063 } 2064 } while (should_repeat && (current_bci != -1)); 2065 st.next(); 2066 } while ((current_bci < 0) && (!st.at_end())); 2067 2068 jmethodID catch_jmethodID; 2069 if (current_bci < 0) { 2070 catch_jmethodID = 0; 2071 current_bci = 0; 2072 } else { 2073 catch_jmethodID = jem.to_jmethodID(current_mh); 2074 } 2075 2076 JvmtiJavaThreadEventTransition jet(thread); 2077 jvmtiEventException callback = env->callbacks()->Exception; 2078 if (callback != nullptr) { 2079 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), 2080 jem.jni_methodID(), jem.location(), 2081 jem.exception(), 2082 catch_jmethodID, current_bci); 2083 } 2084 } 2085 } 2086 } 2087 2088 // frames may get popped because of this throw, be safe - invalidate cached depth 2089 state->invalidate_cur_stack_depth(); 2090 } 2091 2092 2093 void JvmtiExport::notice_unwind_due_to_exception(JavaThread *thread, Method* method, address location, oop exception, bool in_handler_frame) { 2094 HandleMark hm(thread); 2095 methodHandle mh(thread, method); 2096 Handle exception_handle(thread, exception); 2097 2098 JvmtiThreadState *state = get_jvmti_thread_state(thread); 2099 if (state == nullptr) { 2100 return; 2101 } 2102 EVT_TRIG_TRACE(JVMTI_EVENT_EXCEPTION_CATCH, 2103 ("[%s] Trg unwind_due_to_exception triggered %s.%s @ %s" INTX_FORMAT " - %s", 2104 JvmtiTrace::safe_get_thread_name(thread), 2105 (mh() == nullptr) ? "null" : mh()->klass_name()->as_C_string(), 2106 (mh() == nullptr) ? "null" : mh()->name()->as_C_string(), 2107 location==0? "no location:" : "", 2108 location==0? 0 : location - mh()->code_base(), 2109 in_handler_frame? "in handler frame" : "not handler frame" )); 2110 2111 if (state->is_exception_detected()) { 2112 2113 state->invalidate_cur_stack_depth(); 2114 if (!in_handler_frame) { 2115 // Not in exception handler. 2116 if(state->is_interp_only_mode()) { 2117 // method exit and frame pop events are posted only in interp mode. 2118 // When these events are enabled code should be in running in interp mode. 2119 jvalue no_value; 2120 no_value.j = 0L; 2121 JvmtiExport::post_method_exit_inner(thread, mh, state, true, thread->last_frame(), no_value); 2122 // The cached cur_stack_depth might have changed from the 2123 // operations of frame pop or method exit. We are not 100% sure 2124 // the cached cur_stack_depth is still valid depth so invalidate 2125 // it. 2126 state->invalidate_cur_stack_depth(); 2127 } 2128 } else { 2129 // In exception handler frame. Report exception catch. 2130 assert(location != nullptr, "must be a known location"); 2131 // Update cur_stack_depth - the frames above the current frame 2132 // have been unwound due to this exception: 2133 assert(!state->is_exception_caught(), "exception must not be caught yet."); 2134 state->set_exception_caught(); 2135 2136 if (mh->jvmti_mount_transition() || thread->is_in_any_VTMS_transition()) { 2137 return; // no events should be posted if thread is in any VTMS transition 2138 } 2139 JvmtiEnvThreadStateIterator it(state); 2140 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 2141 if (ets->is_enabled(JVMTI_EVENT_EXCEPTION_CATCH) && (exception_handle() != nullptr)) { 2142 EVT_TRACE(JVMTI_EVENT_EXCEPTION_CATCH, 2143 ("[%s] Evt ExceptionCatch sent %s.%s @ " INTX_FORMAT, 2144 JvmtiTrace::safe_get_thread_name(thread), 2145 (mh() == nullptr) ? "null" : mh()->klass_name()->as_C_string(), 2146 (mh() == nullptr) ? "null" : mh()->name()->as_C_string(), 2147 location - mh()->code_base() )); 2148 2149 JvmtiEnv *env = ets->get_env(); 2150 JvmtiExceptionEventMark jem(thread, mh, location, exception_handle); 2151 JvmtiJavaThreadEventTransition jet(thread); 2152 jvmtiEventExceptionCatch callback = env->callbacks()->ExceptionCatch; 2153 if (callback != nullptr) { 2154 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), 2155 jem.jni_methodID(), jem.location(), 2156 jem.exception()); 2157 } 2158 } 2159 } 2160 } 2161 } 2162 } 2163 2164 oop JvmtiExport::jni_GetField_probe(JavaThread *thread, jobject jobj, oop obj, 2165 Klass* klass, jfieldID fieldID, bool is_static) { 2166 if (*((int *)get_field_access_count_addr()) > 0 && thread->has_last_Java_frame()) { 2167 // At least one field access watch is set so we have more work to do. 2168 post_field_access_by_jni(thread, obj, klass, fieldID, is_static); 2169 // event posting can block so refetch oop if we were passed a jobj 2170 if (jobj != nullptr) return JNIHandles::resolve_non_null(jobj); 2171 } 2172 return obj; 2173 } 2174 2175 void JvmtiExport::post_field_access_by_jni(JavaThread *thread, oop obj, 2176 Klass* klass, jfieldID fieldID, bool is_static) { 2177 // We must be called with a Java context in order to provide reasonable 2178 // values for the klazz, method, and location fields. The callers of this 2179 // function don't make the call unless there is a Java context. 2180 assert(thread->has_last_Java_frame(), "must be called with a Java context"); 2181 2182 if (thread->is_in_any_VTMS_transition()) { 2183 return; // no events should be posted if thread is in any VTMS transition 2184 } 2185 2186 ResourceMark rm; 2187 fieldDescriptor fd; 2188 // if get_field_descriptor finds fieldID to be invalid, then we just bail 2189 bool valid_fieldID = JvmtiEnv::get_field_descriptor(klass, fieldID, &fd); 2190 assert(valid_fieldID == true,"post_field_access_by_jni called with invalid fieldID"); 2191 if (!valid_fieldID) return; 2192 // field accesses are not watched so bail 2193 if (!fd.is_field_access_watched()) return; 2194 2195 HandleMark hm(thread); 2196 Handle h_obj; 2197 if (!is_static) { 2198 // non-static field accessors have an object, but we need a handle 2199 assert(obj != nullptr, "non-static needs an object"); 2200 h_obj = Handle(thread, obj); 2201 } 2202 post_field_access(thread, 2203 thread->last_frame().interpreter_frame_method(), 2204 thread->last_frame().interpreter_frame_bcp(), 2205 klass, h_obj, fieldID); 2206 } 2207 2208 void JvmtiExport::post_field_access(JavaThread *thread, Method* method, 2209 address location, Klass* field_klass, Handle object, jfieldID field) { 2210 2211 HandleMark hm(thread); 2212 methodHandle mh(thread, method); 2213 2214 JvmtiThreadState *state = get_jvmti_thread_state(thread); 2215 if (state == nullptr) { 2216 return; 2217 } 2218 if (thread->is_in_any_VTMS_transition()) { 2219 return; // no events should be posted if thread is in any VTMS transition 2220 } 2221 2222 EVT_TRIG_TRACE(JVMTI_EVENT_FIELD_ACCESS, ("[%s] Trg Field Access event triggered", 2223 JvmtiTrace::safe_get_thread_name(thread))); 2224 JvmtiEnvThreadStateIterator it(state); 2225 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 2226 if (ets->is_enabled(JVMTI_EVENT_FIELD_ACCESS)) { 2227 EVT_TRACE(JVMTI_EVENT_FIELD_ACCESS, ("[%s] Evt Field Access event sent %s.%s @ " INTX_FORMAT, 2228 JvmtiTrace::safe_get_thread_name(thread), 2229 (mh() == nullptr) ? "null" : mh()->klass_name()->as_C_string(), 2230 (mh() == nullptr) ? "null" : mh()->name()->as_C_string(), 2231 location - mh()->code_base() )); 2232 2233 JvmtiEnv *env = ets->get_env(); 2234 JvmtiLocationEventMark jem(thread, mh, location); 2235 jclass field_jclass = jem.to_jclass(field_klass); 2236 jobject field_jobject = jem.to_jobject(object()); 2237 JvmtiJavaThreadEventTransition jet(thread); 2238 jvmtiEventFieldAccess callback = env->callbacks()->FieldAccess; 2239 if (callback != nullptr) { 2240 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), 2241 jem.jni_methodID(), jem.location(), 2242 field_jclass, field_jobject, field); 2243 } 2244 } 2245 } 2246 } 2247 2248 oop JvmtiExport::jni_SetField_probe(JavaThread *thread, jobject jobj, oop obj, 2249 Klass* klass, jfieldID fieldID, bool is_static, 2250 char sig_type, jvalue *value) { 2251 if (*((int *)get_field_modification_count_addr()) > 0 && thread->has_last_Java_frame()) { 2252 // At least one field modification watch is set so we have more work to do. 2253 post_field_modification_by_jni(thread, obj, klass, fieldID, is_static, sig_type, value); 2254 // event posting can block so refetch oop if we were passed a jobj 2255 if (jobj != nullptr) return JNIHandles::resolve_non_null(jobj); 2256 } 2257 return obj; 2258 } 2259 2260 void JvmtiExport::post_field_modification_by_jni(JavaThread *thread, oop obj, 2261 Klass* klass, jfieldID fieldID, bool is_static, 2262 char sig_type, jvalue *value) { 2263 // We must be called with a Java context in order to provide reasonable 2264 // values for the klazz, method, and location fields. The callers of this 2265 // function don't make the call unless there is a Java context. 2266 assert(thread->has_last_Java_frame(), "must be called with Java context"); 2267 2268 if (thread->is_in_any_VTMS_transition()) { 2269 return; // no events should be posted if thread is in any VTMS transition 2270 } 2271 2272 ResourceMark rm; 2273 fieldDescriptor fd; 2274 // if get_field_descriptor finds fieldID to be invalid, then we just bail 2275 bool valid_fieldID = JvmtiEnv::get_field_descriptor(klass, fieldID, &fd); 2276 assert(valid_fieldID == true,"post_field_modification_by_jni called with invalid fieldID"); 2277 if (!valid_fieldID) return; 2278 // field modifications are not watched so bail 2279 if (!fd.is_field_modification_watched()) return; 2280 2281 HandleMark hm(thread); 2282 2283 Handle h_obj; 2284 if (!is_static) { 2285 // non-static field accessors have an object, but we need a handle 2286 assert(obj != nullptr, "non-static needs an object"); 2287 h_obj = Handle(thread, obj); 2288 } 2289 post_field_modification(thread, 2290 thread->last_frame().interpreter_frame_method(), 2291 thread->last_frame().interpreter_frame_bcp(), 2292 klass, h_obj, fieldID, sig_type, value); 2293 } 2294 2295 void JvmtiExport::post_raw_field_modification(JavaThread *thread, Method* method, 2296 address location, Klass* field_klass, Handle object, jfieldID field, 2297 char sig_type, jvalue *value) { 2298 2299 if (thread->is_in_any_VTMS_transition()) { 2300 return; // no events should be posted if thread is in any VTMS transition 2301 } 2302 2303 if (sig_type == JVM_SIGNATURE_INT || sig_type == JVM_SIGNATURE_BOOLEAN || 2304 sig_type == JVM_SIGNATURE_BYTE || sig_type == JVM_SIGNATURE_CHAR || 2305 sig_type == JVM_SIGNATURE_SHORT) { 2306 // 'I' instructions are used for byte, char, short and int. 2307 // determine which it really is, and convert 2308 fieldDescriptor fd; 2309 bool found = JvmtiEnv::get_field_descriptor(field_klass, field, &fd); 2310 // should be found (if not, leave as is) 2311 if (found) { 2312 jint ival = value->i; 2313 // convert value from int to appropriate type 2314 switch (fd.field_type()) { 2315 case T_BOOLEAN: 2316 sig_type = JVM_SIGNATURE_BOOLEAN; 2317 value->i = 0; // clear it 2318 value->z = (jboolean)ival; 2319 break; 2320 case T_BYTE: 2321 sig_type = JVM_SIGNATURE_BYTE; 2322 value->i = 0; // clear it 2323 value->b = (jbyte)ival; 2324 break; 2325 case T_CHAR: 2326 sig_type = JVM_SIGNATURE_CHAR; 2327 value->i = 0; // clear it 2328 value->c = (jchar)ival; 2329 break; 2330 case T_SHORT: 2331 sig_type = JVM_SIGNATURE_SHORT; 2332 value->i = 0; // clear it 2333 value->s = (jshort)ival; 2334 break; 2335 case T_INT: 2336 // nothing to do 2337 break; 2338 default: 2339 // this is an integer instruction, should be one of above 2340 ShouldNotReachHere(); 2341 break; 2342 } 2343 } 2344 } 2345 2346 assert(sig_type != JVM_SIGNATURE_ARRAY, "array should have sig_type == 'L'"); 2347 bool handle_created = false; 2348 2349 // convert oop to JNI handle. 2350 if (sig_type == JVM_SIGNATURE_CLASS) { 2351 handle_created = true; 2352 value->l = (jobject)JNIHandles::make_local(thread, cast_to_oop(value->l)); 2353 } 2354 2355 post_field_modification(thread, method, location, field_klass, object, field, sig_type, value); 2356 2357 // Destroy the JNI handle allocated above. 2358 if (handle_created) { 2359 JNIHandles::destroy_local(value->l); 2360 } 2361 } 2362 2363 void JvmtiExport::post_field_modification(JavaThread *thread, Method* method, 2364 address location, Klass* field_klass, Handle object, jfieldID field, 2365 char sig_type, jvalue *value_ptr) { 2366 2367 HandleMark hm(thread); 2368 methodHandle mh(thread, method); 2369 2370 JvmtiThreadState *state = get_jvmti_thread_state(thread); 2371 if (state == nullptr) { 2372 return; 2373 } 2374 if (thread->is_in_any_VTMS_transition()) { 2375 return; // no events should be posted if thread is in any VTMS transition 2376 } 2377 2378 EVT_TRIG_TRACE(JVMTI_EVENT_FIELD_MODIFICATION, 2379 ("[%s] Trg Field Modification event triggered", 2380 JvmtiTrace::safe_get_thread_name(thread))); 2381 JvmtiEnvThreadStateIterator it(state); 2382 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 2383 if (ets->is_enabled(JVMTI_EVENT_FIELD_MODIFICATION)) { 2384 EVT_TRACE(JVMTI_EVENT_FIELD_MODIFICATION, 2385 ("[%s] Evt Field Modification event sent %s.%s @ " INTX_FORMAT, 2386 JvmtiTrace::safe_get_thread_name(thread), 2387 (mh() == nullptr) ? "null" : mh()->klass_name()->as_C_string(), 2388 (mh() == nullptr) ? "null" : mh()->name()->as_C_string(), 2389 location - mh()->code_base() )); 2390 2391 JvmtiEnv *env = ets->get_env(); 2392 JvmtiLocationEventMark jem(thread, mh, location); 2393 jclass field_jclass = jem.to_jclass(field_klass); 2394 jobject field_jobject = jem.to_jobject(object()); 2395 JvmtiJavaThreadEventTransition jet(thread); 2396 jvmtiEventFieldModification callback = env->callbacks()->FieldModification; 2397 if (callback != nullptr) { 2398 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), 2399 jem.jni_methodID(), jem.location(), 2400 field_jclass, field_jobject, field, sig_type, *value_ptr); 2401 } 2402 } 2403 } 2404 } 2405 2406 void JvmtiExport::post_native_method_bind(Method* method, address* function_ptr) { 2407 JavaThread* thread = JavaThread::current(); 2408 assert(thread->thread_state() == _thread_in_vm, "must be in vm state"); 2409 2410 HandleMark hm(thread); 2411 methodHandle mh(thread, method); 2412 2413 if (thread->is_in_any_VTMS_transition()) { 2414 return; // no events should be posted if thread is in any VTMS transition 2415 } 2416 EVT_TRIG_TRACE(JVMTI_EVENT_NATIVE_METHOD_BIND, ("[%s] Trg Native Method Bind event triggered", 2417 JvmtiTrace::safe_get_thread_name(thread))); 2418 2419 if (JvmtiEventController::is_enabled(JVMTI_EVENT_NATIVE_METHOD_BIND)) { 2420 JvmtiEnvIterator it; 2421 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 2422 if (env->is_enabled(JVMTI_EVENT_NATIVE_METHOD_BIND)) { 2423 EVT_TRACE(JVMTI_EVENT_NATIVE_METHOD_BIND, ("[%s] Evt Native Method Bind event sent", 2424 JvmtiTrace::safe_get_thread_name(thread) )); 2425 2426 JvmtiMethodEventMark jem(thread, mh); 2427 JvmtiJavaThreadEventTransition jet(thread); 2428 JNIEnv* jni_env = (env->phase() == JVMTI_PHASE_PRIMORDIAL) ? nullptr : jem.jni_env(); 2429 jvmtiEventNativeMethodBind callback = env->callbacks()->NativeMethodBind; 2430 if (callback != nullptr) { 2431 (*callback)(env->jvmti_external(), jni_env, jem.jni_thread(), 2432 jem.jni_methodID(), (void*)(*function_ptr), (void**)function_ptr); 2433 } 2434 } 2435 } 2436 } 2437 } 2438 2439 // Returns a record containing inlining information for the given nmethod 2440 static jvmtiCompiledMethodLoadInlineRecord* create_inline_record(nmethod* nm) { 2441 jint numstackframes = 0; 2442 jvmtiCompiledMethodLoadInlineRecord* record = (jvmtiCompiledMethodLoadInlineRecord*)NEW_RESOURCE_OBJ(jvmtiCompiledMethodLoadInlineRecord); 2443 record->header.kind = JVMTI_CMLR_INLINE_INFO; 2444 record->header.next = nullptr; 2445 record->header.majorinfoversion = JVMTI_CMLR_MAJOR_VERSION_1; 2446 record->header.minorinfoversion = JVMTI_CMLR_MINOR_VERSION_0; 2447 record->numpcs = 0; 2448 for(PcDesc* p = nm->scopes_pcs_begin(); p < nm->scopes_pcs_end(); p++) { 2449 if(p->scope_decode_offset() == DebugInformationRecorder::serialized_null) continue; 2450 record->numpcs++; 2451 } 2452 record->pcinfo = (PCStackInfo*)(NEW_RESOURCE_ARRAY(PCStackInfo, record->numpcs)); 2453 int scope = 0; 2454 for(PcDesc* p = nm->scopes_pcs_begin(); p < nm->scopes_pcs_end(); p++) { 2455 if(p->scope_decode_offset() == DebugInformationRecorder::serialized_null) continue; 2456 void* pc_address = (void*)p->real_pc(nm); 2457 assert(pc_address != nullptr, "pc_address must be non-null"); 2458 record->pcinfo[scope].pc = pc_address; 2459 numstackframes=0; 2460 for(ScopeDesc* sd = nm->scope_desc_at(p->real_pc(nm));sd != nullptr;sd = sd->sender()) { 2461 numstackframes++; 2462 } 2463 assert(numstackframes != 0, "numstackframes must be nonzero."); 2464 record->pcinfo[scope].methods = (jmethodID *)NEW_RESOURCE_ARRAY(jmethodID, numstackframes); 2465 record->pcinfo[scope].bcis = (jint *)NEW_RESOURCE_ARRAY(jint, numstackframes); 2466 record->pcinfo[scope].numstackframes = numstackframes; 2467 int stackframe = 0; 2468 for(ScopeDesc* sd = nm->scope_desc_at(p->real_pc(nm));sd != nullptr;sd = sd->sender()) { 2469 // sd->method() can be null for stubs but not for nmethods. To be completely robust, include an assert that we should never see a null sd->method() 2470 guarantee(sd->method() != nullptr, "sd->method() cannot be null."); 2471 record->pcinfo[scope].methods[stackframe] = sd->method()->jmethod_id(); 2472 record->pcinfo[scope].bcis[stackframe] = sd->bci(); 2473 stackframe++; 2474 } 2475 scope++; 2476 } 2477 return record; 2478 } 2479 2480 void JvmtiExport::post_compiled_method_load(nmethod *nm) { 2481 guarantee(!nm->is_unloading(), "nmethod isn't unloaded or unloading"); 2482 if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { 2483 return; 2484 } 2485 JavaThread* thread = JavaThread::current(); 2486 2487 assert(!thread->is_in_any_VTMS_transition(), "compiled method load events are not allowed in any VTMS transition"); 2488 2489 EVT_TRIG_TRACE(JVMTI_EVENT_COMPILED_METHOD_LOAD, 2490 ("[%s] method compile load event triggered", 2491 JvmtiTrace::safe_get_thread_name(thread))); 2492 2493 JvmtiEnvIterator it; 2494 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 2495 post_compiled_method_load(env, nm); 2496 } 2497 } 2498 2499 // post a COMPILED_METHOD_LOAD event for a given environment 2500 void JvmtiExport::post_compiled_method_load(JvmtiEnv* env, nmethod *nm) { 2501 if (env->phase() == JVMTI_PHASE_PRIMORDIAL || !env->is_enabled(JVMTI_EVENT_COMPILED_METHOD_LOAD)) { 2502 return; 2503 } 2504 jvmtiEventCompiledMethodLoad callback = env->callbacks()->CompiledMethodLoad; 2505 if (callback == nullptr) { 2506 return; 2507 } 2508 JavaThread* thread = JavaThread::current(); 2509 2510 assert(!thread->is_in_any_VTMS_transition(), "compiled method load events are not allowed in any VTMS transition"); 2511 2512 EVT_TRACE(JVMTI_EVENT_COMPILED_METHOD_LOAD, 2513 ("[%s] method compile load event sent %s.%s ", 2514 JvmtiTrace::safe_get_thread_name(thread), 2515 (nm->method() == nullptr) ? "null" : nm->method()->klass_name()->as_C_string(), 2516 (nm->method() == nullptr) ? "null" : nm->method()->name()->as_C_string())); 2517 ResourceMark rm(thread); 2518 HandleMark hm(thread); 2519 2520 // Add inlining information 2521 jvmtiCompiledMethodLoadInlineRecord* inlinerecord = create_inline_record(nm); 2522 // Pass inlining information through the void pointer 2523 JvmtiCompiledMethodLoadEventMark jem(thread, nm, inlinerecord); 2524 JvmtiJavaThreadEventTransition jet(thread); 2525 (*callback)(env->jvmti_external(), jem.jni_methodID(), 2526 jem.code_size(), jem.code_data(), jem.map_length(), 2527 jem.map(), jem.compile_info()); 2528 } 2529 2530 void JvmtiExport::post_dynamic_code_generated_internal(const char *name, const void *code_begin, const void *code_end) { 2531 assert(name != nullptr && name[0] != '\0', "sanity check"); 2532 2533 JavaThread* thread = JavaThread::current(); 2534 2535 assert(!thread->is_in_any_VTMS_transition(), "dynamic code generated events are not allowed in any VTMS transition"); 2536 2537 // In theory everyone coming thru here is in_vm but we need to be certain 2538 // because a callee will do a vm->native transition 2539 ThreadInVMfromUnknown __tiv; 2540 2541 EVT_TRIG_TRACE(JVMTI_EVENT_DYNAMIC_CODE_GENERATED, 2542 ("[%s] method dynamic code generated event triggered", 2543 JvmtiTrace::safe_get_thread_name(thread))); 2544 JvmtiEnvIterator it; 2545 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 2546 if (env->is_enabled(JVMTI_EVENT_DYNAMIC_CODE_GENERATED)) { 2547 EVT_TRACE(JVMTI_EVENT_DYNAMIC_CODE_GENERATED, 2548 ("[%s] dynamic code generated event sent for %s", 2549 JvmtiTrace::safe_get_thread_name(thread), name)); 2550 JvmtiEventMark jem(thread); 2551 JvmtiJavaThreadEventTransition jet(thread); 2552 jint length = (jint)pointer_delta(code_end, code_begin, sizeof(char)); 2553 jvmtiEventDynamicCodeGenerated callback = env->callbacks()->DynamicCodeGenerated; 2554 if (callback != nullptr) { 2555 (*callback)(env->jvmti_external(), name, (void*)code_begin, length); 2556 } 2557 } 2558 } 2559 } 2560 2561 void JvmtiExport::post_dynamic_code_generated(const char *name, const void *code_begin, const void *code_end) { 2562 jvmtiPhase phase = JvmtiEnv::get_phase(); 2563 if (phase == JVMTI_PHASE_PRIMORDIAL || phase == JVMTI_PHASE_START) { 2564 post_dynamic_code_generated_internal(name, code_begin, code_end); 2565 } else { 2566 // It may not be safe to post the event from this thread. Defer all 2567 // postings to the service thread so that it can perform them in a safe 2568 // context and in-order. 2569 JvmtiDeferredEvent event = JvmtiDeferredEvent::dynamic_code_generated_event( 2570 name, code_begin, code_end); 2571 ServiceThread::enqueue_deferred_event(&event); 2572 } 2573 } 2574 2575 2576 // post a DYNAMIC_CODE_GENERATED event for a given environment 2577 // used by GenerateEvents 2578 void JvmtiExport::post_dynamic_code_generated(JvmtiEnv* env, const char *name, 2579 const void *code_begin, const void *code_end) 2580 { 2581 JavaThread* thread = JavaThread::current(); 2582 2583 assert(!thread->is_in_any_VTMS_transition(), "dynamic code generated events are not allowed in any VTMS transition"); 2584 2585 EVT_TRIG_TRACE(JVMTI_EVENT_DYNAMIC_CODE_GENERATED, 2586 ("[%s] dynamic code generated event triggered (by GenerateEvents)", 2587 JvmtiTrace::safe_get_thread_name(thread))); 2588 if (env->is_enabled(JVMTI_EVENT_DYNAMIC_CODE_GENERATED)) { 2589 EVT_TRACE(JVMTI_EVENT_DYNAMIC_CODE_GENERATED, 2590 ("[%s] dynamic code generated event sent for %s", 2591 JvmtiTrace::safe_get_thread_name(thread), name)); 2592 JvmtiEventMark jem(thread); 2593 JvmtiJavaThreadEventTransition jet(thread); 2594 jint length = (jint)pointer_delta(code_end, code_begin, sizeof(char)); 2595 jvmtiEventDynamicCodeGenerated callback = env->callbacks()->DynamicCodeGenerated; 2596 if (callback != nullptr) { 2597 (*callback)(env->jvmti_external(), name, (void*)code_begin, length); 2598 } 2599 } 2600 } 2601 2602 // post a DynamicCodeGenerated event while holding locks in the VM. 2603 void JvmtiExport::post_dynamic_code_generated_while_holding_locks(const char* name, 2604 address code_begin, address code_end) 2605 { 2606 JavaThread* thread = JavaThread::current(); 2607 // register the stub with the current dynamic code event collector 2608 // Cannot take safepoint here so do not use state_for to get 2609 // jvmti thread state. 2610 // The collector and/or state might be null if JvmtiDynamicCodeEventCollector 2611 // has been initialized while JVMTI_EVENT_DYNAMIC_CODE_GENERATED was disabled. 2612 JvmtiThreadState *state = get_jvmti_thread_state(thread); 2613 if (state != nullptr) { 2614 JvmtiDynamicCodeEventCollector *collector = state->get_dynamic_code_event_collector(); 2615 if (collector != nullptr) { 2616 collector->register_stub(name, code_begin, code_end); 2617 } 2618 } 2619 } 2620 2621 // Collect all the vm internally allocated objects which are visible to java world 2622 void JvmtiExport::record_vm_internal_object_allocation(oop obj) { 2623 Thread* thread = Thread::current_or_null(); 2624 if (thread != nullptr && thread->is_Java_thread()) { 2625 // Can not take safepoint here. 2626 NoSafepointVerifier no_sfpt; 2627 // Cannot take safepoint here so do not use state_for to get 2628 // jvmti thread state. 2629 JvmtiThreadState *state = JavaThread::cast(thread)->jvmti_thread_state(); 2630 if (state != nullptr) { 2631 // state is non null when VMObjectAllocEventCollector is enabled. 2632 JvmtiVMObjectAllocEventCollector *collector; 2633 collector = state->get_vm_object_alloc_event_collector(); 2634 if (collector != nullptr && collector->is_enabled()) { 2635 // Don't record classes as these will be notified via the ClassLoad 2636 // event. 2637 if (obj->klass() != vmClasses::Class_klass()) { 2638 collector->record_allocation(obj); 2639 } 2640 } 2641 } 2642 } 2643 } 2644 2645 // Collect all the sampled allocated objects. 2646 void JvmtiExport::record_sampled_internal_object_allocation(oop obj) { 2647 Thread* thread = Thread::current_or_null(); 2648 if (thread != nullptr && thread->is_Java_thread()) { 2649 // Can not take safepoint here. 2650 NoSafepointVerifier no_sfpt; 2651 // Cannot take safepoint here so do not use state_for to get 2652 // jvmti thread state. 2653 JvmtiThreadState *state = JavaThread::cast(thread)->jvmti_thread_state(); 2654 if (state != nullptr) { 2655 // state is non null when SampledObjectAllocEventCollector is enabled. 2656 JvmtiSampledObjectAllocEventCollector *collector; 2657 collector = state->get_sampled_object_alloc_event_collector(); 2658 2659 if (collector != nullptr && collector->is_enabled()) { 2660 collector->record_allocation(obj); 2661 } 2662 } 2663 } 2664 } 2665 2666 void JvmtiExport::post_garbage_collection_finish() { 2667 Thread *thread = Thread::current(); // this event is posted from VM-Thread. 2668 EVT_TRIG_TRACE(JVMTI_EVENT_GARBAGE_COLLECTION_FINISH, 2669 ("[%s] garbage collection finish event triggered", 2670 JvmtiTrace::safe_get_thread_name(thread))); 2671 JvmtiEnvIterator it; 2672 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 2673 if (env->is_enabled(JVMTI_EVENT_GARBAGE_COLLECTION_FINISH)) { 2674 EVT_TRACE(JVMTI_EVENT_GARBAGE_COLLECTION_FINISH, 2675 ("[%s] garbage collection finish event sent", 2676 JvmtiTrace::safe_get_thread_name(thread))); 2677 JvmtiThreadEventTransition jet(thread); 2678 // JNIEnv is null here because this event is posted from VM Thread 2679 jvmtiEventGarbageCollectionFinish callback = env->callbacks()->GarbageCollectionFinish; 2680 if (callback != nullptr) { 2681 (*callback)(env->jvmti_external()); 2682 } 2683 } 2684 } 2685 } 2686 2687 void JvmtiExport::post_garbage_collection_start() { 2688 Thread* thread = Thread::current(); // this event is posted from vm-thread. 2689 EVT_TRIG_TRACE(JVMTI_EVENT_GARBAGE_COLLECTION_START, 2690 ("[%s] garbage collection start event triggered", 2691 JvmtiTrace::safe_get_thread_name(thread))); 2692 JvmtiEnvIterator it; 2693 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 2694 if (env->is_enabled(JVMTI_EVENT_GARBAGE_COLLECTION_START)) { 2695 EVT_TRACE(JVMTI_EVENT_GARBAGE_COLLECTION_START, 2696 ("[%s] garbage collection start event sent", 2697 JvmtiTrace::safe_get_thread_name(thread))); 2698 JvmtiThreadEventTransition jet(thread); 2699 // JNIEnv is null here because this event is posted from VM Thread 2700 jvmtiEventGarbageCollectionStart callback = env->callbacks()->GarbageCollectionStart; 2701 if (callback != nullptr) { 2702 (*callback)(env->jvmti_external()); 2703 } 2704 } 2705 } 2706 } 2707 2708 void JvmtiExport::post_data_dump() { 2709 Thread *thread = Thread::current(); 2710 EVT_TRIG_TRACE(JVMTI_EVENT_DATA_DUMP_REQUEST, 2711 ("[%s] data dump request event triggered", 2712 JvmtiTrace::safe_get_thread_name(thread))); 2713 JvmtiEnvIterator it; 2714 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 2715 if (env->is_enabled(JVMTI_EVENT_DATA_DUMP_REQUEST)) { 2716 EVT_TRACE(JVMTI_EVENT_DATA_DUMP_REQUEST, 2717 ("[%s] data dump request event sent", 2718 JvmtiTrace::safe_get_thread_name(thread))); 2719 JvmtiThreadEventTransition jet(thread); 2720 // JNIEnv is null here because this event is posted from VM Thread 2721 jvmtiEventDataDumpRequest callback = env->callbacks()->DataDumpRequest; 2722 if (callback != nullptr) { 2723 (*callback)(env->jvmti_external()); 2724 } 2725 } 2726 } 2727 } 2728 2729 void JvmtiExport::post_monitor_contended_enter(JavaThread *thread, ObjectMonitor *obj_mntr) { 2730 oop object = obj_mntr->object(); 2731 HandleMark hm(thread); 2732 Handle h(thread, object); 2733 2734 JvmtiThreadState *state = get_jvmti_thread_state(thread); 2735 if (state == nullptr) { 2736 return; 2737 } 2738 if (thread->is_in_any_VTMS_transition()) { 2739 return; // no events should be posted if thread is in any VTMS transition 2740 } 2741 2742 EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_CONTENDED_ENTER, 2743 ("[%s] monitor contended enter event triggered", 2744 JvmtiTrace::safe_get_thread_name(thread))); 2745 JvmtiEnvThreadStateIterator it(state); 2746 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 2747 if (ets->is_enabled(JVMTI_EVENT_MONITOR_CONTENDED_ENTER)) { 2748 EVT_TRACE(JVMTI_EVENT_MONITOR_CONTENDED_ENTER, 2749 ("[%s] monitor contended enter event sent", 2750 JvmtiTrace::safe_get_thread_name(thread))); 2751 JvmtiMonitorEventMark jem(thread, h()); 2752 JvmtiEnv *env = ets->get_env(); 2753 JvmtiThreadEventTransition jet(thread); 2754 jvmtiEventMonitorContendedEnter callback = env->callbacks()->MonitorContendedEnter; 2755 if (callback != nullptr) { 2756 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_object()); 2757 } 2758 } 2759 } 2760 } 2761 2762 void JvmtiExport::post_monitor_contended_entered(JavaThread *thread, ObjectMonitor *obj_mntr) { 2763 oop object = obj_mntr->object(); 2764 HandleMark hm(thread); 2765 Handle h(thread, object); 2766 2767 JvmtiThreadState *state = get_jvmti_thread_state(thread); 2768 if (state == nullptr) { 2769 return; 2770 } 2771 if (thread->is_in_any_VTMS_transition()) { 2772 return; // no events should be posted if thread is in any VTMS transition 2773 } 2774 2775 EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_CONTENDED_ENTERED, 2776 ("[%s] monitor contended entered event triggered", 2777 JvmtiTrace::safe_get_thread_name(thread))); 2778 2779 JvmtiEnvThreadStateIterator it(state); 2780 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 2781 if (ets->is_enabled(JVMTI_EVENT_MONITOR_CONTENDED_ENTERED)) { 2782 EVT_TRACE(JVMTI_EVENT_MONITOR_CONTENDED_ENTERED, 2783 ("[%s] monitor contended enter event sent", 2784 JvmtiTrace::safe_get_thread_name(thread))); 2785 JvmtiMonitorEventMark jem(thread, h()); 2786 JvmtiEnv *env = ets->get_env(); 2787 JvmtiThreadEventTransition jet(thread); 2788 jvmtiEventMonitorContendedEntered callback = env->callbacks()->MonitorContendedEntered; 2789 if (callback != nullptr) { 2790 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_object()); 2791 } 2792 } 2793 } 2794 } 2795 2796 void JvmtiExport::post_monitor_wait(JavaThread *thread, oop object, 2797 jlong timeout) { 2798 HandleMark hm(thread); 2799 Handle h(thread, object); 2800 2801 JvmtiThreadState *state = get_jvmti_thread_state(thread); 2802 if (state == nullptr) { 2803 return; 2804 } 2805 if (thread->is_in_any_VTMS_transition()) { 2806 return; // no events should be posted if thread is in any VTMS transition 2807 } 2808 2809 EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_WAIT, 2810 ("[%s] monitor wait event triggered", 2811 JvmtiTrace::safe_get_thread_name(thread))); 2812 JvmtiEnvThreadStateIterator it(state); 2813 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 2814 if (ets->is_enabled(JVMTI_EVENT_MONITOR_WAIT)) { 2815 EVT_TRACE(JVMTI_EVENT_MONITOR_WAIT, 2816 ("[%s] monitor wait event sent", 2817 JvmtiTrace::safe_get_thread_name(thread))); 2818 JvmtiMonitorEventMark jem(thread, h()); 2819 JvmtiEnv *env = ets->get_env(); 2820 JvmtiThreadEventTransition jet(thread); 2821 jvmtiEventMonitorWait callback = env->callbacks()->MonitorWait; 2822 if (callback != nullptr) { 2823 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), 2824 jem.jni_object(), timeout); 2825 } 2826 } 2827 } 2828 } 2829 2830 void JvmtiExport::post_monitor_waited(JavaThread *thread, ObjectMonitor *obj_mntr, jboolean timed_out) { 2831 oop object = obj_mntr->object(); 2832 HandleMark hm(thread); 2833 Handle h(thread, object); 2834 2835 JvmtiThreadState *state = get_jvmti_thread_state(thread); 2836 if (state == nullptr) { 2837 return; 2838 } 2839 if (thread->is_in_any_VTMS_transition()) { 2840 return; // no events should be posted if thread is in any VTMS transition 2841 } 2842 2843 EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_WAITED, 2844 ("[%s] monitor waited event triggered", 2845 JvmtiTrace::safe_get_thread_name(thread))); 2846 JvmtiEnvThreadStateIterator it(state); 2847 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 2848 if (ets->is_enabled(JVMTI_EVENT_MONITOR_WAITED)) { 2849 EVT_TRACE(JVMTI_EVENT_MONITOR_WAITED, 2850 ("[%s] monitor waited event sent", 2851 JvmtiTrace::safe_get_thread_name(thread))); 2852 JvmtiMonitorEventMark jem(thread, h()); 2853 JvmtiEnv *env = ets->get_env(); 2854 JvmtiThreadEventTransition jet(thread); 2855 jvmtiEventMonitorWaited callback = env->callbacks()->MonitorWaited; 2856 if (callback != nullptr) { 2857 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), 2858 jem.jni_object(), timed_out); 2859 } 2860 } 2861 } 2862 } 2863 2864 void JvmtiExport::post_vm_object_alloc(JavaThread *thread, oop object) { 2865 if (object == nullptr) { 2866 return; 2867 } 2868 if (thread->is_in_any_VTMS_transition()) { 2869 return; // no events should be posted if thread is in any VTMS transition 2870 } 2871 HandleMark hm(thread); 2872 Handle h(thread, object); 2873 2874 EVT_TRIG_TRACE(JVMTI_EVENT_VM_OBJECT_ALLOC, ("[%s] Trg vm object alloc triggered", 2875 JvmtiTrace::safe_get_thread_name(thread))); 2876 JvmtiEnvIterator it; 2877 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 2878 if (env->is_enabled(JVMTI_EVENT_VM_OBJECT_ALLOC)) { 2879 EVT_TRACE(JVMTI_EVENT_VM_OBJECT_ALLOC, ("[%s] Evt vmobject alloc sent %s", 2880 JvmtiTrace::safe_get_thread_name(thread), 2881 object==nullptr? "null" : object->klass()->external_name())); 2882 2883 JvmtiObjectAllocEventMark jem(thread, h()); 2884 JvmtiJavaThreadEventTransition jet(thread); 2885 jvmtiEventVMObjectAlloc callback = env->callbacks()->VMObjectAlloc; 2886 if (callback != nullptr) { 2887 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), 2888 jem.jni_jobject(), jem.jni_class(), jem.size()); 2889 } 2890 } 2891 } 2892 } 2893 2894 void JvmtiExport::post_sampled_object_alloc(JavaThread *thread, oop object) { 2895 HandleMark hm(thread); 2896 Handle h(thread, object); 2897 2898 JvmtiThreadState *state = get_jvmti_thread_state(thread); 2899 if (state == nullptr) { 2900 return; 2901 } 2902 if (object == nullptr) { 2903 return; 2904 } 2905 if (thread->is_in_any_VTMS_transition()) { 2906 return; // no events should be posted if thread is in any VTMS transition 2907 } 2908 2909 EVT_TRIG_TRACE(JVMTI_EVENT_SAMPLED_OBJECT_ALLOC, 2910 ("[%s] Trg sampled object alloc triggered", 2911 JvmtiTrace::safe_get_thread_name(thread))); 2912 JvmtiEnvThreadStateIterator it(state); 2913 for (JvmtiEnvThreadState* ets = it.first(); ets != nullptr; ets = it.next(ets)) { 2914 if (ets->is_enabled(JVMTI_EVENT_SAMPLED_OBJECT_ALLOC)) { 2915 EVT_TRACE(JVMTI_EVENT_SAMPLED_OBJECT_ALLOC, 2916 ("[%s] Evt sampled object alloc sent %s", 2917 JvmtiTrace::safe_get_thread_name(thread), 2918 object == nullptr ? "null" : object->klass()->external_name())); 2919 2920 JvmtiEnv *env = ets->get_env(); 2921 JvmtiObjectAllocEventMark jem(thread, h()); 2922 JvmtiJavaThreadEventTransition jet(thread); 2923 jvmtiEventSampledObjectAlloc callback = env->callbacks()->SampledObjectAlloc; 2924 if (callback != nullptr) { 2925 (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), 2926 jem.jni_jobject(), jem.jni_class(), jem.size()); 2927 } 2928 } 2929 } 2930 } 2931 2932 //////////////////////////////////////////////////////////////////////////////////////////////// 2933 2934 void JvmtiExport::cleanup_thread(JavaThread* thread) { 2935 assert(JavaThread::current() == thread, "thread is not current"); 2936 MutexLocker mu(thread, JvmtiThreadState_lock); 2937 2938 if (thread->jvmti_thread_state() != nullptr) { 2939 // This has to happen after the thread state is removed, which is 2940 // why it is not in post_thread_end_event like its complement 2941 // Maybe both these functions should be rolled into the posts? 2942 JvmtiEventController::thread_ended(thread); 2943 } 2944 } 2945 2946 void JvmtiExport::clear_detected_exception(JavaThread* thread) { 2947 assert(JavaThread::current() == thread, "thread is not current"); 2948 2949 JvmtiThreadState* state = thread->jvmti_thread_state(); 2950 if (state != nullptr) { 2951 state->clear_exception_state(); 2952 } 2953 } 2954 2955 // Onload raw monitor transition. 2956 void JvmtiExport::transition_pending_onload_raw_monitors() { 2957 JvmtiPendingMonitors::transition_raw_monitors(); 2958 } 2959 2960 // Setup current current thread for event collection. 2961 void JvmtiEventCollector::setup_jvmti_thread_state() { 2962 // set this event collector to be the current one. 2963 JvmtiThreadState* state = JvmtiThreadState::state_for(JavaThread::current()); 2964 // state can only be null if the current thread is exiting which 2965 // should not happen since we're trying to configure for event collection 2966 guarantee(state != nullptr, "exiting thread called setup_jvmti_thread_state"); 2967 if (is_vm_object_alloc_event()) { 2968 JvmtiVMObjectAllocEventCollector *prev = state->get_vm_object_alloc_event_collector(); 2969 2970 // If we have a previous collector and it is disabled, it means this allocation came from a 2971 // callback induced VM Object allocation, do not register this collector then. 2972 if (prev && !prev->is_enabled()) { 2973 return; 2974 } 2975 _prev = prev; 2976 state->set_vm_object_alloc_event_collector((JvmtiVMObjectAllocEventCollector *)this); 2977 } else if (is_dynamic_code_event()) { 2978 _prev = state->get_dynamic_code_event_collector(); 2979 state->set_dynamic_code_event_collector((JvmtiDynamicCodeEventCollector *)this); 2980 } else if (is_sampled_object_alloc_event()) { 2981 JvmtiSampledObjectAllocEventCollector *prev = state->get_sampled_object_alloc_event_collector(); 2982 2983 if (prev) { 2984 // JvmtiSampledObjectAllocEventCollector wants only one active collector 2985 // enabled. This allows to have a collector detect a user code requiring 2986 // a sample in the callback. 2987 return; 2988 } 2989 state->set_sampled_object_alloc_event_collector((JvmtiSampledObjectAllocEventCollector*) this); 2990 } 2991 2992 _unset_jvmti_thread_state = true; 2993 } 2994 2995 // Unset current event collection in this thread and reset it with previous 2996 // collector. 2997 void JvmtiEventCollector::unset_jvmti_thread_state() { 2998 if (!_unset_jvmti_thread_state) { 2999 return; 3000 } 3001 3002 JvmtiThreadState* state = JavaThread::current()->jvmti_thread_state(); 3003 if (state != nullptr) { 3004 // restore the previous event collector (if any) 3005 if (is_vm_object_alloc_event()) { 3006 if (state->get_vm_object_alloc_event_collector() == this) { 3007 state->set_vm_object_alloc_event_collector((JvmtiVMObjectAllocEventCollector *)_prev); 3008 } else { 3009 // this thread's jvmti state was created during the scope of 3010 // the event collector. 3011 } 3012 } else if (is_dynamic_code_event()) { 3013 if (state->get_dynamic_code_event_collector() == this) { 3014 state->set_dynamic_code_event_collector((JvmtiDynamicCodeEventCollector *)_prev); 3015 } else { 3016 // this thread's jvmti state was created during the scope of 3017 // the event collector. 3018 } 3019 } else if (is_sampled_object_alloc_event()) { 3020 if (state->get_sampled_object_alloc_event_collector() == this) { 3021 state->set_sampled_object_alloc_event_collector((JvmtiSampledObjectAllocEventCollector*)_prev); 3022 } else { 3023 // this thread's jvmti state was created during the scope of 3024 // the event collector. 3025 } 3026 } 3027 } 3028 } 3029 3030 // create the dynamic code event collector 3031 JvmtiDynamicCodeEventCollector::JvmtiDynamicCodeEventCollector() : _code_blobs(nullptr) { 3032 if (JvmtiExport::should_post_dynamic_code_generated()) { 3033 setup_jvmti_thread_state(); 3034 } 3035 } 3036 3037 // iterate over any code blob descriptors collected and post a 3038 // DYNAMIC_CODE_GENERATED event to the profiler. 3039 JvmtiDynamicCodeEventCollector::~JvmtiDynamicCodeEventCollector() { 3040 assert(!JavaThread::current()->owns_locks(), "all locks must be released to post deferred events"); 3041 // iterate over any code blob descriptors that we collected 3042 if (_code_blobs != nullptr) { 3043 for (int i=0; i<_code_blobs->length(); i++) { 3044 JvmtiCodeBlobDesc* blob = _code_blobs->at(i); 3045 JvmtiExport::post_dynamic_code_generated(blob->name(), blob->code_begin(), blob->code_end()); 3046 FreeHeap(blob); 3047 } 3048 delete _code_blobs; 3049 } 3050 unset_jvmti_thread_state(); 3051 } 3052 3053 // register a stub 3054 void JvmtiDynamicCodeEventCollector::register_stub(const char* name, address start, address end) { 3055 if (_code_blobs == nullptr) { 3056 _code_blobs = new (mtServiceability) GrowableArray<JvmtiCodeBlobDesc*>(1, mtServiceability); 3057 } 3058 _code_blobs->append(new JvmtiCodeBlobDesc(name, start, end)); 3059 } 3060 3061 // Setup current thread to record vm allocated objects. 3062 JvmtiObjectAllocEventCollector::JvmtiObjectAllocEventCollector() : 3063 _allocated(nullptr), _enable(false), _post_callback(nullptr) { 3064 } 3065 3066 // Post vm_object_alloc event for vm allocated objects visible to java 3067 // world. 3068 void JvmtiObjectAllocEventCollector::generate_call_for_allocated() { 3069 if (_allocated) { 3070 set_enabled(false); 3071 for (int i = 0; i < _allocated->length(); i++) { 3072 oop obj = _allocated->at(i).resolve(); 3073 _post_callback(JavaThread::current(), obj); 3074 // Release OopHandle 3075 _allocated->at(i).release(JvmtiExport::jvmti_oop_storage()); 3076 3077 } 3078 delete _allocated, _allocated = nullptr; 3079 } 3080 } 3081 3082 void JvmtiObjectAllocEventCollector::record_allocation(oop obj) { 3083 assert(is_enabled(), "Object alloc event collector is not enabled"); 3084 if (_allocated == nullptr) { 3085 _allocated = new (mtServiceability) GrowableArray<OopHandle>(1, mtServiceability); 3086 } 3087 _allocated->push(OopHandle(JvmtiExport::jvmti_oop_storage(), obj)); 3088 } 3089 3090 // Disable collection of VMObjectAlloc events 3091 NoJvmtiVMObjectAllocMark::NoJvmtiVMObjectAllocMark() : _collector(nullptr) { 3092 // a no-op if VMObjectAlloc event is not enabled 3093 if (!JvmtiExport::should_post_vm_object_alloc()) { 3094 return; 3095 } 3096 Thread* thread = Thread::current_or_null(); 3097 if (thread != nullptr && thread->is_Java_thread()) { 3098 JavaThread* current_thread = JavaThread::cast(thread); 3099 JvmtiThreadState *state = current_thread->jvmti_thread_state(); 3100 if (state != nullptr) { 3101 JvmtiVMObjectAllocEventCollector *collector; 3102 collector = state->get_vm_object_alloc_event_collector(); 3103 if (collector != nullptr && collector->is_enabled()) { 3104 _collector = collector; 3105 _collector->set_enabled(false); 3106 } 3107 } 3108 } 3109 } 3110 3111 // Re-Enable collection of VMObjectAlloc events (if previously enabled) 3112 NoJvmtiVMObjectAllocMark::~NoJvmtiVMObjectAllocMark() { 3113 if (was_enabled()) { 3114 _collector->set_enabled(true); 3115 } 3116 }; 3117 3118 // Setup current thread to record vm allocated objects. 3119 JvmtiVMObjectAllocEventCollector::JvmtiVMObjectAllocEventCollector() { 3120 if (JvmtiExport::should_post_vm_object_alloc()) { 3121 _enable = true; 3122 setup_jvmti_thread_state(); 3123 _post_callback = JvmtiExport::post_vm_object_alloc; 3124 } 3125 } 3126 3127 JvmtiVMObjectAllocEventCollector::~JvmtiVMObjectAllocEventCollector() { 3128 if (_enable) { 3129 generate_call_for_allocated(); 3130 } 3131 unset_jvmti_thread_state(); 3132 } 3133 3134 bool JvmtiSampledObjectAllocEventCollector::object_alloc_is_safe_to_sample() { 3135 Thread* thread = Thread::current(); 3136 // Really only sample allocations if this is a JavaThread and not the compiler 3137 // thread. 3138 if (!thread->is_Java_thread() || thread->is_Compiler_thread()) { 3139 return false; 3140 } 3141 3142 // If the current thread is attaching from native and its Java thread object 3143 // is being allocated, things are not ready for allocation sampling. 3144 JavaThread* jt = JavaThread::cast(thread); 3145 if (jt->is_attaching_via_jni() && jt->threadObj() == nullptr) { 3146 return false; 3147 } 3148 3149 return true; 3150 } 3151 3152 // Setup current thread to record sampled allocated objects. 3153 void JvmtiSampledObjectAllocEventCollector::start() { 3154 if (JvmtiExport::should_post_sampled_object_alloc()) { 3155 if (!object_alloc_is_safe_to_sample()) { 3156 return; 3157 } 3158 3159 _enable = true; 3160 setup_jvmti_thread_state(); 3161 _post_callback = JvmtiExport::post_sampled_object_alloc; 3162 } 3163 } 3164 3165 JvmtiSampledObjectAllocEventCollector::~JvmtiSampledObjectAllocEventCollector() { 3166 if (!_enable) { 3167 return; 3168 } 3169 3170 generate_call_for_allocated(); 3171 unset_jvmti_thread_state(); 3172 3173 // Unset the sampling collector as present in assertion mode only. 3174 assert(Thread::current()->is_Java_thread(), 3175 "Should always be in a Java thread"); 3176 } 3177 3178 JvmtiGCMarker::JvmtiGCMarker() { 3179 // if there aren't any JVMTI environments then nothing to do 3180 if (!JvmtiEnv::environments_might_exist()) { 3181 return; 3182 } 3183 3184 if (JvmtiExport::should_post_garbage_collection_start()) { 3185 JvmtiExport::post_garbage_collection_start(); 3186 } 3187 3188 if (SafepointSynchronize::is_at_safepoint()) { 3189 // Do clean up tasks that need to be done at a safepoint 3190 JvmtiEnvBase::check_for_periodic_clean_up(); 3191 } 3192 } 3193 3194 JvmtiGCMarker::~JvmtiGCMarker() { 3195 // if there aren't any JVMTI environments then nothing to do 3196 if (!JvmtiEnv::environments_might_exist()) { 3197 return; 3198 } 3199 3200 // JVMTI notify gc finish 3201 if (JvmtiExport::should_post_garbage_collection_finish()) { 3202 JvmtiExport::post_garbage_collection_finish(); 3203 } 3204 }