926 // generated code from being reused too early. We pass
927 // zombie_ok == true here so that our nmethod that was just
928 // made into a zombie can be locked.
929 nmethodLocker::lock_nmethod(nm, true /* zombie_ok */);
930 return event;
931 }
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 // Need to make a copy of the name since we don't know how long
937 // the event poster will keep it around after we enqueue the
938 // deferred event and return. strdup() failure is handled in
939 // the post() routine below.
940 event._event_data.dynamic_code_generated.name = os::strdup(name);
941 event._event_data.dynamic_code_generated.code_begin = code_begin;
942 event._event_data.dynamic_code_generated.code_end = code_end;
943 return event;
944 }
945
946 void JvmtiDeferredEvent::post() {
947 assert(ServiceThread::is_service_thread(Thread::current()),
948 "Service thread must post enqueued events");
949 switch(_type) {
950 case TYPE_COMPILED_METHOD_LOAD: {
951 nmethod* nm = _event_data.compiled_method_load;
952 JvmtiExport::post_compiled_method_load(nm);
953 // done with the deferred event so unlock the nmethod
954 nmethodLocker::unlock_nmethod(nm);
955 break;
956 }
957 case TYPE_COMPILED_METHOD_UNLOAD: {
958 nmethod* nm = _event_data.compiled_method_unload.nm;
959 JvmtiExport::post_compiled_method_unload(
960 _event_data.compiled_method_unload.method_id,
961 _event_data.compiled_method_unload.code_begin);
962 // done with the deferred event so unlock the nmethod
963 nmethodLocker::unlock_nmethod(nm);
964 break;
965 }
966 case TYPE_DYNAMIC_CODE_GENERATED: {
967 JvmtiExport::post_dynamic_code_generated_internal(
968 // if strdup failed give the event a default name
969 (_event_data.dynamic_code_generated.name == NULL)
970 ? "unknown_code" : _event_data.dynamic_code_generated.name,
971 _event_data.dynamic_code_generated.code_begin,
972 _event_data.dynamic_code_generated.code_end);
973 if (_event_data.dynamic_code_generated.name != NULL) {
974 // release our copy
975 os::free((void *)_event_data.dynamic_code_generated.name);
976 }
977 break;
978 }
979 default:
980 ShouldNotReachHere();
981 }
982 }
983
984 JvmtiDeferredEventQueue::QueueNode* JvmtiDeferredEventQueue::_queue_tail = NULL;
985 JvmtiDeferredEventQueue::QueueNode* JvmtiDeferredEventQueue::_queue_head = NULL;
986
987 bool JvmtiDeferredEventQueue::has_events() {
988 assert(Service_lock->owned_by_self(), "Must own Service_lock");
989 return _queue_head != NULL;
990 }
991
992 void JvmtiDeferredEventQueue::enqueue(const JvmtiDeferredEvent& event) {
993 assert(Service_lock->owned_by_self(), "Must own Service_lock");
994
995 // Events get added to the end of the queue (and are pulled off the front).
|
926 // generated code from being reused too early. We pass
927 // zombie_ok == true here so that our nmethod that was just
928 // made into a zombie can be locked.
929 nmethodLocker::lock_nmethod(nm, true /* zombie_ok */);
930 return event;
931 }
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 // Need to make a copy of the name since we don't know how long
937 // the event poster will keep it around after we enqueue the
938 // deferred event and return. strdup() failure is handled in
939 // the post() routine below.
940 event._event_data.dynamic_code_generated.name = os::strdup(name);
941 event._event_data.dynamic_code_generated.code_begin = code_begin;
942 event._event_data.dynamic_code_generated.code_end = code_end;
943 return event;
944 }
945
946 JvmtiDeferredEvent JvmtiDeferredEvent::class_unload_event(const char* name) {
947 JvmtiDeferredEvent event = JvmtiDeferredEvent(TYPE_CLASS_UNLOADED);
948 // Need to make a copy of the name since we don't know how long
949 // the event poster will keep it around after we enqueue the
950 // deferred event and return. strdup() failure is handled in
951 // the post() routine below.
952 event._event_data.class_unloaded.name = os::strdup(name);
953 return event;
954 }
955
956 void JvmtiDeferredEvent::post() {
957 assert(ServiceThread::is_service_thread(Thread::current()),
958 "Service thread must post enqueued events");
959 switch(_type) {
960 case TYPE_COMPILED_METHOD_LOAD: {
961 nmethod* nm = _event_data.compiled_method_load;
962 JvmtiExport::post_compiled_method_load(nm);
963 // done with the deferred event so unlock the nmethod
964 nmethodLocker::unlock_nmethod(nm);
965 break;
966 }
967 case TYPE_COMPILED_METHOD_UNLOAD: {
968 nmethod* nm = _event_data.compiled_method_unload.nm;
969 JvmtiExport::post_compiled_method_unload(
970 _event_data.compiled_method_unload.method_id,
971 _event_data.compiled_method_unload.code_begin);
972 // done with the deferred event so unlock the nmethod
973 nmethodLocker::unlock_nmethod(nm);
974 break;
975 }
976 case TYPE_DYNAMIC_CODE_GENERATED: {
977 JvmtiExport::post_dynamic_code_generated_internal(
978 // if strdup failed give the event a default name
979 (_event_data.dynamic_code_generated.name == NULL)
980 ? "unknown_code" : _event_data.dynamic_code_generated.name,
981 _event_data.dynamic_code_generated.code_begin,
982 _event_data.dynamic_code_generated.code_end);
983 if (_event_data.dynamic_code_generated.name != NULL) {
984 // release our copy
985 os::free((void *)_event_data.dynamic_code_generated.name);
986 }
987 break;
988 }
989 case TYPE_CLASS_UNLOADED: {
990 JvmtiExport::post_class_unload_internal(
991 // if strdup failed give the event a default name
992 (_event_data.class_unloaded.name == NULL)
993 ? "unknown_class" : _event_data.class_unloaded.name);
994 if (_event_data.class_unloaded.name != NULL) {
995 // release our copy
996 os::free((void *)_event_data.class_unloaded.name);
997 }
998 break;
999 }
1000 default:
1001 ShouldNotReachHere();
1002 }
1003 }
1004
1005 JvmtiDeferredEventQueue::QueueNode* JvmtiDeferredEventQueue::_queue_tail = NULL;
1006 JvmtiDeferredEventQueue::QueueNode* JvmtiDeferredEventQueue::_queue_head = NULL;
1007
1008 bool JvmtiDeferredEventQueue::has_events() {
1009 assert(Service_lock->owned_by_self(), "Must own Service_lock");
1010 return _queue_head != NULL;
1011 }
1012
1013 void JvmtiDeferredEventQueue::enqueue(const JvmtiDeferredEvent& event) {
1014 assert(Service_lock->owned_by_self(), "Must own Service_lock");
1015
1016 // Events get added to the end of the queue (and are pulled off the front).
|