902 const char *name = JvmtiTrace::safe_get_thread_name(thread);
903 #else
904 const char *name = "";
905 #endif /*JVMTI_TRACE */
906 tty->print("%s(%c ", name, thread->is_being_ext_suspended() ? 'S' : '_');
907 if (!thread->has_last_Java_frame()) {
908 tty->print("no stack");
909 }
910 tty->print(") ");
911 }
912 tty->print_cr("]");
913 #endif
914 }
915
916 #ifndef KERNEL
917
918 JvmtiDeferredEvent JvmtiDeferredEvent::compiled_method_load_event(
919 nmethod* nm) {
920 JvmtiDeferredEvent event = JvmtiDeferredEvent(TYPE_COMPILED_METHOD_LOAD);
921 event._event_data.compiled_method_load = nm;
922 nmethodLocker::lock_nmethod(nm); // will be unlocked when posted
923 return event;
924 }
925
926 JvmtiDeferredEvent JvmtiDeferredEvent::compiled_method_unload_event(
927 jmethodID id, const void* code) {
928 JvmtiDeferredEvent event = JvmtiDeferredEvent(TYPE_COMPILED_METHOD_UNLOAD);
929 event._event_data.compiled_method_unload.method_id = id;
930 event._event_data.compiled_method_unload.code_begin = code;
931 return event;
932 }
933 JvmtiDeferredEvent JvmtiDeferredEvent::dynamic_code_generated_event(
934 const char* name, const void* code_begin, const void* code_end) {
935 JvmtiDeferredEvent event = JvmtiDeferredEvent(TYPE_DYNAMIC_CODE_GENERATED);
936 event._event_data.dynamic_code_generated.name = name;
937 event._event_data.dynamic_code_generated.code_begin = code_begin;
938 event._event_data.dynamic_code_generated.code_end = code_end;
939 return event;
940 }
941
942 void JvmtiDeferredEvent::post() {
943 assert(ServiceThread::is_service_thread(Thread::current()),
944 "Service thread must post enqueued events");
945 switch(_type) {
946 case TYPE_COMPILED_METHOD_LOAD: {
947 nmethod* nm = _event_data.compiled_method_load;
948 JvmtiExport::post_compiled_method_load(nm);
949 nmethodLocker::unlock_nmethod(nm);
950 break;
951 }
952 case TYPE_COMPILED_METHOD_UNLOAD:
953 JvmtiExport::post_compiled_method_unload(
954 _event_data.compiled_method_unload.method_id,
955 _event_data.compiled_method_unload.code_begin);
956 break;
957 case TYPE_DYNAMIC_CODE_GENERATED:
958 JvmtiExport::post_dynamic_code_generated_internal(
959 _event_data.dynamic_code_generated.name,
960 _event_data.dynamic_code_generated.code_begin,
961 _event_data.dynamic_code_generated.code_end);
962 break;
963 default:
964 ShouldNotReachHere();
965 }
966 }
967
968 JvmtiDeferredEventQueue::QueueNode* JvmtiDeferredEventQueue::_queue_tail = NULL;
969 JvmtiDeferredEventQueue::QueueNode* JvmtiDeferredEventQueue::_queue_head = NULL;
970
971 volatile JvmtiDeferredEventQueue::QueueNode*
972 JvmtiDeferredEventQueue::_pending_list = NULL;
973
974 bool JvmtiDeferredEventQueue::has_events() {
975 assert(Service_lock->owned_by_self(), "Must own Service_lock");
976 return _queue_head != NULL || _pending_list != NULL;
|
902 const char *name = JvmtiTrace::safe_get_thread_name(thread);
903 #else
904 const char *name = "";
905 #endif /*JVMTI_TRACE */
906 tty->print("%s(%c ", name, thread->is_being_ext_suspended() ? 'S' : '_');
907 if (!thread->has_last_Java_frame()) {
908 tty->print("no stack");
909 }
910 tty->print(") ");
911 }
912 tty->print_cr("]");
913 #endif
914 }
915
916 #ifndef KERNEL
917
918 JvmtiDeferredEvent JvmtiDeferredEvent::compiled_method_load_event(
919 nmethod* nm) {
920 JvmtiDeferredEvent event = JvmtiDeferredEvent(TYPE_COMPILED_METHOD_LOAD);
921 event._event_data.compiled_method_load = nm;
922 // Keep the nmethod alive until the ServiceThread can process
923 // this deferred event.
924 nmethodLocker::lock_nmethod(nm);
925 return event;
926 }
927
928 JvmtiDeferredEvent JvmtiDeferredEvent::compiled_method_unload_event(
929 nmethod* nm, jmethodID id, const void* code) {
930 JvmtiDeferredEvent event = JvmtiDeferredEvent(TYPE_COMPILED_METHOD_UNLOAD);
931 event._event_data.compiled_method_unload.nm = nm;
932 event._event_data.compiled_method_unload.method_id = id;
933 event._event_data.compiled_method_unload.code_begin = code;
934 // Keep the nmethod alive until the ServiceThread can process
935 // this deferred event. This will keep the memory for the
936 // generated code from being reused too early. We pass
937 // zombie_ok == true here so that our nmethod that was just
938 // made into a zombie can be locked.
939 nmethodLocker::lock_nmethod(nm, true /* zombie_ok */);
940 return event;
941 }
942 JvmtiDeferredEvent JvmtiDeferredEvent::dynamic_code_generated_event(
943 const char* name, const void* code_begin, const void* code_end) {
944 JvmtiDeferredEvent event = JvmtiDeferredEvent(TYPE_DYNAMIC_CODE_GENERATED);
945 event._event_data.dynamic_code_generated.name = name;
946 event._event_data.dynamic_code_generated.code_begin = code_begin;
947 event._event_data.dynamic_code_generated.code_end = code_end;
948 return event;
949 }
950
951 void JvmtiDeferredEvent::post() {
952 assert(ServiceThread::is_service_thread(Thread::current()),
953 "Service thread must post enqueued events");
954 switch(_type) {
955 case TYPE_COMPILED_METHOD_LOAD: {
956 nmethod* nm = _event_data.compiled_method_load;
957 JvmtiExport::post_compiled_method_load(nm);
958 // done with the deferred event so unlock the nmethod
959 nmethodLocker::unlock_nmethod(nm);
960 break;
961 }
962 case TYPE_COMPILED_METHOD_UNLOAD: {
963 nmethod* nm = _event_data.compiled_method_unload.nm;
964 JvmtiExport::post_compiled_method_unload(
965 _event_data.compiled_method_unload.method_id,
966 _event_data.compiled_method_unload.code_begin);
967 // done with the deferred event so unlock the nmethod
968 nmethodLocker::unlock_nmethod(nm);
969 break;
970 }
971 case TYPE_DYNAMIC_CODE_GENERATED:
972 JvmtiExport::post_dynamic_code_generated_internal(
973 _event_data.dynamic_code_generated.name,
974 _event_data.dynamic_code_generated.code_begin,
975 _event_data.dynamic_code_generated.code_end);
976 break;
977 default:
978 ShouldNotReachHere();
979 }
980 }
981
982 JvmtiDeferredEventQueue::QueueNode* JvmtiDeferredEventQueue::_queue_tail = NULL;
983 JvmtiDeferredEventQueue::QueueNode* JvmtiDeferredEventQueue::_queue_head = NULL;
984
985 volatile JvmtiDeferredEventQueue::QueueNode*
986 JvmtiDeferredEventQueue::_pending_list = NULL;
987
988 bool JvmtiDeferredEventQueue::has_events() {
989 assert(Service_lock->owned_by_self(), "Must own Service_lock");
990 return _queue_head != NULL || _pending_list != NULL;
|