< prev index next > src/hotspot/share/prims/jvmtiExport.cpp
Print this page
_jt = (jthread)(to_jobject(thread->threadObj()));
};
jthread jni_thread() { return _jt; }
};
! class JvmtiClassEventMark : public JvmtiThreadEventMark {
private:
jclass _jc;
public:
JvmtiClassEventMark(JavaThread *thread, Klass* klass) :
! JvmtiThreadEventMark(thread) {
_jc = to_jclass(klass);
};
jclass jni_class() { return _jc; }
};
! class JvmtiMethodEventMark : public JvmtiThreadEventMark {
private:
jmethodID _mid;
public:
JvmtiMethodEventMark(JavaThread *thread, const methodHandle& method) :
! JvmtiThreadEventMark(thread),
_mid(to_jmethodID(method)) {};
jmethodID jni_methodID() { return _mid; }
};
class JvmtiLocationEventMark : public JvmtiMethodEventMark {
_jt = (jthread)(to_jobject(thread->threadObj()));
};
jthread jni_thread() { return _jt; }
};
! class JvmtiVirtualThreadEventMark : public JvmtiEventMark {
+ private:
+ jthread _jt;
+
+ public:
+ JvmtiVirtualThreadEventMark(JavaThread *thread) :
+ JvmtiEventMark(thread) {
+ JvmtiThreadState* state = thread->jvmti_thread_state();
+ if (state != NULL && state->is_virtual()) {
+ _jt = (jthread)(to_jobject(thread->vthread()));
+ } else {
+ _jt = (jthread)(to_jobject(thread->threadObj()));
+ }
+ };
+ jthread jni_thread() { return _jt; }
+ };
+
+ class JvmtiClassEventMark : public JvmtiVirtualThreadEventMark {
private:
jclass _jc;
public:
JvmtiClassEventMark(JavaThread *thread, Klass* klass) :
! JvmtiVirtualThreadEventMark(thread) {
_jc = to_jclass(klass);
};
jclass jni_class() { return _jc; }
};
! class JvmtiMethodEventMark : public JvmtiVirtualThreadEventMark {
private:
jmethodID _mid;
public:
JvmtiMethodEventMark(JavaThread *thread, const methodHandle& method) :
! JvmtiVirtualThreadEventMark(thread),
_mid(to_jmethodID(method)) {};
jmethodID jni_methodID() { return _mid; }
};
class JvmtiLocationEventMark : public JvmtiMethodEventMark {
}
// Looks like an oop at this point.
if (!thread_oop->is_a(vmClasses::Thread_klass())) {
// The oop is not a java.lang.Thread.
+ if (thread_oop_p != NULL) {
+ *thread_oop_p = NULL;
+ }
return JVMTI_ERROR_INVALID_THREAD;
}
// Looks like a java.lang.Thread oop at this point.
if (thread_oop_p != NULL) {
*thread_oop_p = thread_oop;
}
JavaThread * java_thread = java_lang_Thread::thread(thread_oop);
if (java_thread == NULL) {
+ if (java_lang_VirtualThread::is_instance(thread_oop)) {
+ return JVMTI_ERROR_INVALID_THREAD;
+ }
// The java.lang.Thread does not contain a JavaThread * so it has
// not yet run or it has died.
return JVMTI_ERROR_THREAD_NOT_ALIVE;
}
// Looks like a live JavaThread at this point.
const void *compile_info() { return _compile_info; }
};
! class JvmtiMonitorEventMark : public JvmtiThreadEventMark {
private:
jobject _jobj;
public:
JvmtiMonitorEventMark(JavaThread *thread, oop object)
! : JvmtiThreadEventMark(thread){
_jobj = to_jobject(object);
}
jobject jni_object() { return _jobj; }
};
const void *compile_info() { return _compile_info; }
};
! class JvmtiMonitorEventMark : public JvmtiVirtualThreadEventMark {
private:
jobject _jobj;
public:
JvmtiMonitorEventMark(JavaThread *thread, oop object)
! : JvmtiVirtualThreadEventMark(thread){
_jobj = to_jobject(object);
}
jobject jni_object() { return _jobj; }
};
JvmtiThreadState *state = thread->jvmti_thread_state();
if (state == NULL) {
return;
}
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
+
EVT_TRIG_TRACE(JVMTI_EVENT_BREAKPOINT, ("[%s] Trg Breakpoint triggered",
JvmtiTrace::safe_get_thread_name(thread)));
JvmtiEnvThreadStateIterator it(state);
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
ets->compare_and_set_current_location(mh(), location, JVMTI_EVENT_BREAKPOINT);
bool JvmtiExport::_can_post_breakpoint = false;
bool JvmtiExport::_can_post_field_access = false;
bool JvmtiExport::_can_post_field_modification = false;
bool JvmtiExport::_can_post_method_entry = false;
bool JvmtiExport::_can_post_method_exit = false;
+ bool JvmtiExport::_can_post_frame_pop = false;
bool JvmtiExport::_can_pop_frame = false;
bool JvmtiExport::_can_force_early_return = false;
+ bool JvmtiExport::_can_support_virtual_threads = false;
bool JvmtiExport::_can_get_owned_monitor_info = false;
bool JvmtiExport::_early_vmstart_recorded = false;
bool JvmtiExport::_should_post_single_step = false;
bool JvmtiExport::_should_post_object_free = false;
bool JvmtiExport::_should_post_resource_exhausted = false;
bool JvmtiExport::_should_post_vm_object_alloc = false;
bool JvmtiExport::_should_post_sampled_object_alloc = false;
bool JvmtiExport::_should_post_on_exceptions = false;
+ bool JvmtiExport::_should_post_vthread_start = false;
+ bool JvmtiExport::_should_post_vthread_end = false;
+ bool JvmtiExport::_should_post_vthread_mount = false;
+ bool JvmtiExport::_should_post_vthread_unmount = false;
////////////////////////////////////////////////////////////////////////////////////////////////
+ void JvmtiExport::check_suspend_at_safepoint(JavaThread *thread) {
+ oop vt = thread->mounted_vthread();
+
+ if (vt != NULL && java_lang_VirtualThread::is_instance(vt)) {
+ HandleMark hm(thread);
+ Handle vth = Handle(thread, vt);
+
+ ThreadBlockInVM tbivm(thread);
+ MonitorLocker ml(JvmtiVTMT_lock, Mutex::_no_safepoint_check_flag);
+
+ #ifdef DBG // TMP
+ JvmtiThreadState* state = thread->jvmti_thread_state();
+
+ if (state != NULL) {
+ printf("DBG: JvmtiExport::check_suspend_at_safepoint: state: %p virt: %d jt: %p vt-susp: %d ct-susp: %d\n",
+ (void*)state, state->is_virtual(), (void*)thread,
+ JvmtiVTSuspender::is_vthread_suspended(vt),
+ thread->is_thread_suspended()
+ );
+ fflush(0);
+ }
+ #endif
+ // block while vthread is externally suspended
+ while (JvmtiVTSuspender::is_vthread_suspended(vth())) {
+ ml.wait();
+ }
+ }
+ }
+
//
// JVMTI single step management
//
void JvmtiExport::at_single_stepping_point(JavaThread *thread, Method* method, address location) {
assert(JvmtiExport::should_post_single_step(), "must be single stepping");
JvmtiTrace::safe_get_thread_name(thread)));
JvmtiThreadState* state = thread->jvmti_thread_state();
if (state == NULL) {
return;
}
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
JvmtiEnvThreadStateIterator it(state);
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
if (ets->is_enabled(JVMTI_EVENT_CLASS_LOAD)) {
JvmtiEnv *env = ets->get_env();
if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
JvmtiTrace::safe_get_thread_name(thread)));
JvmtiThreadState* state = thread->jvmti_thread_state();
if (state == NULL) {
return;
}
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
JvmtiEnvThreadStateIterator it(state);
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
if (ets->is_enabled(JVMTI_EVENT_CLASS_PREPARE)) {
JvmtiEnv *env = ets->get_env();
if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
}
if (env->is_enabled(JVMTI_EVENT_THREAD_START)) {
EVT_TRACE(JVMTI_EVENT_THREAD_START, ("[%s] Evt Thread Start event sent",
JvmtiTrace::safe_get_thread_name(thread) ));
! JvmtiThreadEventMark jem(thread);
JvmtiJavaThreadEventTransition jet(thread);
jvmtiEventThreadStart callback = env->callbacks()->ThreadStart;
if (callback != NULL) {
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread());
}
}
if (env->is_enabled(JVMTI_EVENT_THREAD_START)) {
EVT_TRACE(JVMTI_EVENT_THREAD_START, ("[%s] Evt Thread Start event sent",
JvmtiTrace::safe_get_thread_name(thread) ));
! JvmtiVirtualThreadEventMark jem(thread);
JvmtiJavaThreadEventTransition jet(thread);
jvmtiEventThreadStart callback = env->callbacks()->ThreadStart;
if (callback != NULL) {
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread());
}
continue;
}
EVT_TRACE(JVMTI_EVENT_THREAD_END, ("[%s] Evt Thread End event sent",
JvmtiTrace::safe_get_thread_name(thread) ));
! JvmtiThreadEventMark jem(thread);
JvmtiJavaThreadEventTransition jet(thread);
jvmtiEventThreadEnd callback = env->callbacks()->ThreadEnd;
if (callback != NULL) {
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread());
}
}
}
}
}
void JvmtiExport::post_object_free(JvmtiEnv* env, jlong tag) {
assert(env->is_enabled(JVMTI_EVENT_OBJECT_FREE), "checking");
EVT_TRIG_TRACE(JVMTI_EVENT_OBJECT_FREE, ("[?] Trg Object Free triggered" ));
EVT_TRACE(JVMTI_EVENT_OBJECT_FREE, ("[?] Evt Object Free sent"));
continue;
}
EVT_TRACE(JVMTI_EVENT_THREAD_END, ("[%s] Evt Thread End event sent",
JvmtiTrace::safe_get_thread_name(thread) ));
! JvmtiVirtualThreadEventMark jem(thread);
JvmtiJavaThreadEventTransition jet(thread);
jvmtiEventThreadEnd callback = env->callbacks()->ThreadEnd;
if (callback != NULL) {
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread());
}
}
}
}
}
+
+ void JvmtiExport::post_vthread_start(jobject vthread) {
+ if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
+ return;
+ }
+ EVT_TRIG_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_START, ("[%p] Trg Virtual Thread Start event triggered", vthread));
+
+ JavaThread *cur_thread = JavaThread::current();
+ JvmtiThreadState *state = cur_thread->jvmti_thread_state();
+ if (state == NULL) {
+ return;
+ }
+
+ if (state->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_START)) {
+ JvmtiEnvThreadStateIterator it(state);
+
+ for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
+ JvmtiEnv *env = ets->get_env();
+ if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
+ continue;
+ }
+ if (ets->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_START)) {
+ EVT_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_START, ("[%p] Evt Virtual Thread Start event sent", vthread));
+
+ JvmtiVirtualThreadEventMark jem(cur_thread);
+ JvmtiJavaThreadEventTransition jet(cur_thread);
+ jvmtiEventVirtualThreadStart callback = env->callbacks()->VirtualThreadStart;
+ if (callback != NULL) {
+ (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread());
+ }
+ }
+ }
+ }
+ }
+
+ void JvmtiExport::post_vthread_end(jobject vthread) {
+ if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
+ return;
+ }
+ EVT_TRIG_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_END, ("[%p] Trg Virtual Thread End event triggered", vthread));
+
+ JavaThread *cur_thread = JavaThread::current();
+ JvmtiThreadState *state = cur_thread->jvmti_thread_state();
+ if (state == NULL) {
+ return;
+ }
+
+ if (state->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_END)) {
+ JvmtiEnvThreadStateIterator it(state);
+
+ for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
+ JvmtiEnv *env = ets->get_env();
+ if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
+ continue;
+ }
+ if (ets->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_END)) {
+ EVT_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_END, ("[%p] Evt Virtual Thread End event sent", vthread));
+
+ JvmtiVirtualThreadEventMark jem(cur_thread);
+ JvmtiJavaThreadEventTransition jet(cur_thread);
+ jvmtiEventVirtualThreadEnd callback = env->callbacks()->VirtualThreadEnd;
+ if (callback != NULL) {
+ (*callback)(env->jvmti_external(), jem.jni_env(), vthread);
+ }
+ }
+ }
+ }
+ }
+
+ void JvmtiExport::post_vthread_mount(jobject vthread) {
+ if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
+ return;
+ }
+ JavaThread *thread = JavaThread::current();
+ HandleMark hm(thread);
+ EVT_TRIG_TRACE(EXT_EVENT_VIRTUAL_THREAD_MOUNT, ("[%p] Trg Virtual Thread Mount event triggered", vthread));
+
+ JvmtiThreadState *state = thread->jvmti_thread_state();
+ if (state == NULL) {
+ return;
+ }
+
+ if (state->is_enabled((jvmtiEvent)EXT_EVENT_VIRTUAL_THREAD_MOUNT)) {
+ JvmtiEnvThreadStateIterator it(state);
+
+ for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
+ JvmtiEnv *env = ets->get_env();
+ if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
+ continue;
+ }
+ if (ets->is_enabled((jvmtiEvent)EXT_EVENT_VIRTUAL_THREAD_MOUNT)) {
+ EVT_TRACE(EXT_EVENT_VIRTUAL_THREAD_MOUNT, ("[%p] Evt Virtual Thread Mount event sent", vthread));
+
+ JvmtiVirtualThreadEventMark jem(thread);
+ JvmtiJavaThreadEventTransition jet(thread);
+ jvmtiExtensionEvent callback = env->ext_callbacks()->VirtualThreadMount;
+ if (callback != NULL) {
+ (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread());
+ }
+ }
+ }
+ }
+ }
+
+ void JvmtiExport::post_vthread_unmount(jobject vthread) {
+ if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
+ return;
+ }
+ JavaThread *thread = JavaThread::current();
+ HandleMark hm(thread);
+ EVT_TRIG_TRACE(EXT_EVENT_VIRTUAL_THREAD_UNMOUNT, ("[%p] Trg Virtual Thread Unmount event triggered", vthread));
+
+ JvmtiThreadState *state = thread->jvmti_thread_state();
+ if (state == NULL) {
+ return;
+ }
+
+ if (state->is_enabled((jvmtiEvent)EXT_EVENT_VIRTUAL_THREAD_UNMOUNT)) {
+ JvmtiEnvThreadStateIterator it(state);
+
+ for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
+ JvmtiEnv *env = ets->get_env();
+ if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
+ continue;
+ }
+ if (ets->is_enabled((jvmtiEvent)EXT_EVENT_VIRTUAL_THREAD_UNMOUNT)) {
+ EVT_TRACE(EXT_EVENT_VIRTUAL_THREAD_UNMOUNT, ("[%p] Evt Virtual Thread Unmount event sent", vthread));
+
+ JvmtiVirtualThreadEventMark jem(thread);
+ JvmtiJavaThreadEventTransition jet(thread);
+ jvmtiExtensionEvent callback = env->ext_callbacks()->VirtualThreadUnmount;
+ if (callback != NULL) {
+ (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread());
+ }
+ }
+ }
+ }
+ }
+
+ void JvmtiExport::continuation_yield_cleanup(JavaThread* thread, jint continuation_frame_count) {
+ if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
+ return;
+ }
+
+ assert (thread == JavaThread::current(), "must be");
+ JvmtiThreadState *state = thread->jvmti_thread_state();
+ if (state == NULL) {
+ return;
+ }
+ state->invalidate_cur_stack_depth();
+
+ // Clear frame_pop requests in frames popped by yield
+ if (can_post_frame_pop()) {
+ JvmtiEnvThreadStateIterator it(state);
+ int top_frame_num = state->cur_stack_depth() + continuation_frame_count;
+
+ for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
+ if (!ets->has_frame_pops()) {
+ continue;
+ }
+ for (int frame_idx = 0; frame_idx < continuation_frame_count; frame_idx++) {
+ int frame_num = top_frame_num - frame_idx;
+
+ if (!state->is_virtual() && ets->is_frame_pop(frame_num)) {
+ // remove the frame's entry
+ MutexLocker mu(JvmtiThreadState_lock);
+ ets->clear_frame_pop(frame_num);
+ }
+ }
+ }
+ }
+ }
+
void JvmtiExport::post_object_free(JvmtiEnv* env, jlong tag) {
assert(env->is_enabled(JVMTI_EVENT_OBJECT_FREE), "checking");
EVT_TRIG_TRACE(JVMTI_EVENT_OBJECT_FREE, ("[?] Trg Object Free triggered" ));
EVT_TRACE(JVMTI_EVENT_OBJECT_FREE, ("[?] Evt Object Free sent"));
JvmtiThreadState* state = thread->jvmti_thread_state();
if (state == NULL || !state->is_interp_only_mode()) {
// for any thread that actually wants method entry, interp_only_mode is set
return;
}
+ if (mh->jvmti_mount_transition() || thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
state->incr_cur_stack_depth();
if (state->is_enabled(JVMTI_EVENT_METHOD_ENTRY)) {
JvmtiEnvThreadStateIterator it(state);
if (state == NULL || !state->is_interp_only_mode()) {
// for any thread that actually wants method exit, interp_only_mode is set
return;
}
+ if (mh->jvmti_mount_transition() || thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
// return a flag when a method terminates by throwing an exception
// i.e. if an exception is thrown and it's not caught by the current method
bool exception_exit = state->is_exception_detected() && !state->is_exception_caught();
Handle result;
}
}
}
state->decr_cur_stack_depth();
+
}
// Todo: inline this for optimization
void JvmtiExport::post_single_step(JavaThread *thread, Method* method, address location) {
JvmtiThreadState *state = thread->jvmti_thread_state();
if (state == NULL) {
return;
}
+ if (mh->jvmti_mount_transition() || thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
+
JvmtiEnvThreadStateIterator it(state);
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
ets->compare_and_set_current_location(mh(), location, JVMTI_EVENT_SINGLE_STEP);
if (!ets->single_stepping_posted() && ets->is_enabled(JVMTI_EVENT_SINGLE_STEP)) {
EVT_TRACE(JVMTI_EVENT_SINGLE_STEP, ("[%s] Evt Single Step sent %s.%s @ " INTX_FORMAT,
JvmtiThreadState *state = thread->jvmti_thread_state();
if (state == NULL) {
return;
}
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
EVT_TRIG_TRACE(JVMTI_EVENT_EXCEPTION, ("[%s] Trg Exception thrown triggered",
JvmtiTrace::safe_get_thread_name(thread)));
if (!state->is_exception_detected()) {
state->set_exception_detected();
// We must be called with a Java context in order to provide reasonable
// values for the klazz, method, and location fields. The callers of this
// function don't make the call unless there is a Java context.
assert(thread->has_last_Java_frame(), "must be called with a Java context");
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
+
ResourceMark rm;
fieldDescriptor fd;
// if get_field_descriptor finds fieldID to be invalid, then we just bail
bool valid_fieldID = JvmtiEnv::get_field_descriptor(klass, fieldID, &fd);
assert(valid_fieldID == true,"post_field_access_by_jni called with invalid fieldID");
JvmtiThreadState *state = thread->jvmti_thread_state();
if (state == NULL) {
return;
}
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
+
EVT_TRIG_TRACE(JVMTI_EVENT_FIELD_ACCESS, ("[%s] Trg Field Access event triggered",
JvmtiTrace::safe_get_thread_name(thread)));
JvmtiEnvThreadStateIterator it(state);
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
if (ets->is_enabled(JVMTI_EVENT_FIELD_ACCESS)) {
// We must be called with a Java context in order to provide reasonable
// values for the klazz, method, and location fields. The callers of this
// function don't make the call unless there is a Java context.
assert(thread->has_last_Java_frame(), "must be called with Java context");
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
+
ResourceMark rm;
fieldDescriptor fd;
// if get_field_descriptor finds fieldID to be invalid, then we just bail
bool valid_fieldID = JvmtiEnv::get_field_descriptor(klass, fieldID, &fd);
assert(valid_fieldID == true,"post_field_modification_by_jni called with invalid fieldID");
void JvmtiExport::post_raw_field_modification(JavaThread *thread, Method* method,
address location, Klass* field_klass, Handle object, jfieldID field,
char sig_type, jvalue *value) {
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
+
if (sig_type == JVM_SIGNATURE_INT || sig_type == JVM_SIGNATURE_BOOLEAN ||
sig_type == JVM_SIGNATURE_BYTE || sig_type == JVM_SIGNATURE_CHAR ||
sig_type == JVM_SIGNATURE_SHORT) {
// 'I' instructions are used for byte, char, short and int.
// determine which it really is, and convert
JvmtiThreadState *state = thread->jvmti_thread_state();
if (state == NULL) {
return;
}
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
+
EVT_TRIG_TRACE(JVMTI_EVENT_FIELD_MODIFICATION,
("[%s] Trg Field Modification event triggered",
JvmtiTrace::safe_get_thread_name(thread)));
JvmtiEnvThreadStateIterator it(state);
methodHandle mh(thread, method);
EVT_TRIG_TRACE(JVMTI_EVENT_NATIVE_METHOD_BIND, ("[%s] Trg Native Method Bind event triggered",
JvmtiTrace::safe_get_thread_name(thread)));
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
+
if (JvmtiEventController::is_enabled(JVMTI_EVENT_NATIVE_METHOD_BIND)) {
JvmtiEnvIterator it;
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
if (env->is_enabled(JVMTI_EVENT_NATIVE_METHOD_BIND)) {
EVT_TRACE(JVMTI_EVENT_NATIVE_METHOD_BIND, ("[%s] Evt Native Method Bind event sent",
oop object = obj_mntr->object();
JvmtiThreadState *state = thread->jvmti_thread_state();
if (state == NULL) {
return;
}
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
HandleMark hm(thread);
Handle h(thread, object);
EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_CONTENDED_ENTER,
oop object = obj_mntr->object();
JvmtiThreadState *state = thread->jvmti_thread_state();
if (state == NULL) {
return;
}
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
HandleMark hm(thread);
Handle h(thread, object);
EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_CONTENDED_ENTERED,
jlong timeout) {
JvmtiThreadState *state = thread->jvmti_thread_state();
if (state == NULL) {
return;
}
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
HandleMark hm(thread);
Handle h(thread, object);
EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_WAIT,
oop object = obj_mntr->object();
JvmtiThreadState *state = thread->jvmti_thread_state();
if (state == NULL) {
return;
}
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
HandleMark hm(thread);
Handle h(thread, object);
EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_WAITED,
EVT_TRIG_TRACE(JVMTI_EVENT_VM_OBJECT_ALLOC, ("[%s] Trg vm object alloc triggered",
JvmtiTrace::safe_get_thread_name(thread)));
if (object == NULL) {
return;
}
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
HandleMark hm(thread);
Handle h(thread, object);
JvmtiEnvIterator it;
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
if (env->is_enabled(JVMTI_EVENT_VM_OBJECT_ALLOC)) {
("[%s] Trg sampled object alloc triggered",
JvmtiTrace::safe_get_thread_name(thread)));
if (object == NULL) {
return;
}
+ if (thread->is_in_VTMT()) {
+ return; // no events should be posted if thread is in a VTMT transition
+ }
HandleMark hm(thread);
Handle h(thread, object);
JvmtiEnvThreadStateIterator it(state);
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
< prev index next >