862 if (thread_oop == NULL) {
863 return err;
864 }
865 // We have a valid thread_oop so we can return some thread state.
866 }
867 }
868
869 // get most state bits
870 jint state = (jint)java_lang_Thread::get_thread_status(thread_oop);
871
872 if (java_thread != NULL) {
873 // We have a JavaThread* so add more state bits.
874 JavaThreadState jts = java_thread->thread_state();
875
876 if (java_thread->is_being_ext_suspended()) {
877 state |= JVMTI_THREAD_STATE_SUSPENDED;
878 }
879 if (jts == _thread_in_native) {
880 state |= JVMTI_THREAD_STATE_IN_NATIVE;
881 }
882 OSThread* osThread = java_thread->osthread();
883 if (osThread != NULL && osThread->interrupted()) {
884 state |= JVMTI_THREAD_STATE_INTERRUPTED;
885 }
886 }
887
888 *thread_state_ptr = state;
889 return JVMTI_ERROR_NONE;
890 } /* end GetThreadState */
891
892
893 // thread_ptr - pre-checked for NULL
894 jvmtiError
895 JvmtiEnv::GetCurrentThread(jthread* thread_ptr) {
896 JavaThread* current_thread = JavaThread::current();
897 *thread_ptr = (jthread)JNIHandles::make_local(current_thread, current_thread->threadObj());
898 return JVMTI_ERROR_NONE;
899 } /* end GetCurrentThread */
900
901
902 // threads_count_ptr - pre-checked for NULL
903 // threads_ptr - pre-checked for NULL
1075
1076
1077 // Threads_lock NOT held, java_thread not protected by lock
1078 // java_thread - pre-checked
1079 jvmtiError
1080 JvmtiEnv::StopThread(JavaThread* java_thread, jobject exception) {
1081 oop e = JNIHandles::resolve_external_guard(exception);
1082 NULL_CHECK(e, JVMTI_ERROR_NULL_POINTER);
1083
1084 JavaThread::send_async_exception(java_thread->threadObj(), e);
1085
1086 return JVMTI_ERROR_NONE;
1087
1088 } /* end StopThread */
1089
1090
1091 // Threads_lock NOT held
1092 // thread - NOT pre-checked
1093 jvmtiError
1094 JvmtiEnv::InterruptThread(jthread thread) {
1095 // TODO: this is very similar to JVM_Interrupt(); share code in future
1096 JavaThread* current_thread = JavaThread::current();
1097 JavaThread* java_thread = NULL;
1098 ThreadsListHandle tlh(current_thread);
1099 jvmtiError err = JvmtiExport::cv_external_thread_to_JavaThread(tlh.list(), thread, &java_thread, NULL);
1100 if (err != JVMTI_ERROR_NONE) {
1101 return err;
1102 }
1103
1104 java_thread->interrupt();
1105
1106 return JVMTI_ERROR_NONE;
1107 } /* end InterruptThread */
1108
1109
1110 // Threads_lock NOT held
1111 // thread - NOT pre-checked
1112 // info_ptr - pre-checked for NULL
1113 jvmtiError
1114 JvmtiEnv::GetThreadInfo(jthread thread, jvmtiThreadInfo* info_ptr) {
1115 ResourceMark rm;
1116 HandleMark hm;
1117
1118 JavaThread* current_thread = JavaThread::current();
1119 ThreadsListHandle tlh(current_thread);
1120
1121 // if thread is NULL the current thread is used
1122 oop thread_oop = NULL;
1123 if (thread == NULL) {
|
862 if (thread_oop == NULL) {
863 return err;
864 }
865 // We have a valid thread_oop so we can return some thread state.
866 }
867 }
868
869 // get most state bits
870 jint state = (jint)java_lang_Thread::get_thread_status(thread_oop);
871
872 if (java_thread != NULL) {
873 // We have a JavaThread* so add more state bits.
874 JavaThreadState jts = java_thread->thread_state();
875
876 if (java_thread->is_being_ext_suspended()) {
877 state |= JVMTI_THREAD_STATE_SUSPENDED;
878 }
879 if (jts == _thread_in_native) {
880 state |= JVMTI_THREAD_STATE_IN_NATIVE;
881 }
882 if (java_thread->is_interrupted(false)) {
883 state |= JVMTI_THREAD_STATE_INTERRUPTED;
884 }
885 }
886
887 *thread_state_ptr = state;
888 return JVMTI_ERROR_NONE;
889 } /* end GetThreadState */
890
891
892 // thread_ptr - pre-checked for NULL
893 jvmtiError
894 JvmtiEnv::GetCurrentThread(jthread* thread_ptr) {
895 JavaThread* current_thread = JavaThread::current();
896 *thread_ptr = (jthread)JNIHandles::make_local(current_thread, current_thread->threadObj());
897 return JVMTI_ERROR_NONE;
898 } /* end GetCurrentThread */
899
900
901 // threads_count_ptr - pre-checked for NULL
902 // threads_ptr - pre-checked for NULL
1074
1075
1076 // Threads_lock NOT held, java_thread not protected by lock
1077 // java_thread - pre-checked
1078 jvmtiError
1079 JvmtiEnv::StopThread(JavaThread* java_thread, jobject exception) {
1080 oop e = JNIHandles::resolve_external_guard(exception);
1081 NULL_CHECK(e, JVMTI_ERROR_NULL_POINTER);
1082
1083 JavaThread::send_async_exception(java_thread->threadObj(), e);
1084
1085 return JVMTI_ERROR_NONE;
1086
1087 } /* end StopThread */
1088
1089
1090 // Threads_lock NOT held
1091 // thread - NOT pre-checked
1092 jvmtiError
1093 JvmtiEnv::InterruptThread(jthread thread) {
1094 JavaThread* current_thread = JavaThread::current();
1095 JavaThread* java_thread = NULL;
1096 ThreadsListHandle tlh(current_thread);
1097 jvmtiError err = JvmtiExport::cv_external_thread_to_JavaThread(tlh.list(), thread, &java_thread, NULL);
1098 if (err != JVMTI_ERROR_NONE) {
1099 return err;
1100 }
1101 // Really this should be a Java call to Thread.interrupt to ensure the same
1102 // semantics, however historically this has not been done for some reason.
1103 // So we continue with that (which means we don't interact with any Java-level
1104 // Interruptible object) but we must set the Java-level interrupted state.
1105 java_lang_Thread::set_interrupted(JNIHandles::resolve(thread), true);
1106 java_thread->interrupt();
1107
1108 return JVMTI_ERROR_NONE;
1109 } /* end InterruptThread */
1110
1111
1112 // Threads_lock NOT held
1113 // thread - NOT pre-checked
1114 // info_ptr - pre-checked for NULL
1115 jvmtiError
1116 JvmtiEnv::GetThreadInfo(jthread thread, jvmtiThreadInfo* info_ptr) {
1117 ResourceMark rm;
1118 HandleMark hm;
1119
1120 JavaThread* current_thread = JavaThread::current();
1121 ThreadsListHandle tlh(current_thread);
1122
1123 // if thread is NULL the current thread is used
1124 oop thread_oop = NULL;
1125 if (thread == NULL) {
|