From d6df67efcd64255f685a4556c20690f56315dad0 Mon Sep 17 00:00:00 2001 From: Keith Seitz Date: Mon, 5 Feb 2007 21:28:55 +0000 Subject: [PATCH] jvmti.cc (_envListLock): Change type to ReentrantReadWriteLock. * jvmti.cc (_envListLock): Change type to ReentrantReadWriteLock. (_Jv_JVMTI_DisposeEnvironment): Switch to read/write lock. (check_enabled_event): Likewise. (_Jv_GetJVMTIEnv): Likewise. (_Jv_JVMTI_Init): Likewise. (_Jv_JVMTI_PostEvent): Likewise. From-SVN: r121616 --- libjava/ChangeLog | 11 +++++++ libjava/jvmti.cc | 77 +++++++++++++++++++++++++++-------------------- 2 files changed, 55 insertions(+), 33 deletions(-) diff --git a/libjava/ChangeLog b/libjava/ChangeLog index f94ac741f3b..4b244ff957c 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,14 @@ +2007-02-05 Keith Seitz + + * jvmti.cc (_envListLock): Change type to + ReentrantReadWriteLock. + (_Jv_JVMTI_DisposeEnvironment): Switch to read/write + lock. + (check_enabled_event): Likewise. + (_Jv_GetJVMTIEnv): Likewise. + (_Jv_JVMTI_Init): Likewise. + (_Jv_JVMTI_PostEvent): Likewise. + 2007-02-05 Keith Seitz * gnu/classpath/jdwp/natVMVirtualMachine.cc diff --git a/libjava/jvmti.cc b/libjava/jvmti.cc index 2e32634b202..e14bd7c5005 100644 --- a/libjava/jvmti.cc +++ b/libjava/jvmti.cc @@ -27,7 +27,6 @@ details. */ #include #include -#include #include #include #include @@ -37,6 +36,8 @@ details. */ #include #include #include +#include +#include #include static void check_enabled_events (void); @@ -103,7 +104,8 @@ struct jvmti_env_list struct jvmti_env_list *next; }; static struct jvmti_env_list *_jvmtiEnvironments = NULL; -static java::lang::Object *_envListLock = NULL; +static java::util::concurrent::locks:: +ReentrantReadWriteLock *_envListLock = NULL; #define FOREACH_ENVIRONMENT(Ele) \ for (Ele = _jvmtiEnvironments; Ele != NULL; Ele = Ele->next) @@ -896,7 +898,7 @@ _Jv_JVMTI_DisposeEnvironment (jvmtiEnv *env) return JVMTI_ERROR_INVALID_ENVIRONMENT; else { - JvSynchronize dummy (_envListLock); + _envListLock->writeLock ()->lock (); if (_jvmtiEnvironments->env == env) { struct jvmti_env_list *next = _jvmtiEnvironments->next; @@ -909,12 +911,16 @@ _Jv_JVMTI_DisposeEnvironment (jvmtiEnv *env) while (e->next != NULL && e->next->env != env) e = e->next; if (e->next == NULL) - return JVMTI_ERROR_INVALID_ENVIRONMENT; + { + _envListLock->writeLock ()->unlock (); + return JVMTI_ERROR_INVALID_ENVIRONMENT; + } struct jvmti_env_list *next = e->next->next; _Jv_Free (e->next); e->next = next; } + _envListLock->writeLock ()->unlock (); } _Jv_Free (env); @@ -1215,18 +1221,24 @@ check_enabled_event (jvmtiEvent type) int index = EVENT_INDEX (type); // safe since caller checks this - JvSynchronize dummy (_envListLock); - struct jvmti_env_list *e; - FOREACH_ENVIRONMENT (e) + if (_jvmtiEnvironments != NULL) { - char *addr - = reinterpret_cast (&e->env->callbacks) + offset; - void **callback = reinterpret_cast (addr); - if (e->env->enabled[index] && *callback != NULL) + _envListLock->readLock ()->lock (); + struct jvmti_env_list *e; + FOREACH_ENVIRONMENT (e) { - *enabled = true; - return; + char *addr + = reinterpret_cast (&e->env->callbacks) + offset; + void **callback = reinterpret_cast (addr); + if (e->env->enabled[index] && *callback != NULL) + { + *enabled = true; + _envListLock->readLock ()->unlock (); + return; + } } + + _envListLock->readLock ()->unlock (); } *enabled = false; @@ -1739,24 +1751,22 @@ _Jv_GetJVMTIEnv (void) _Jv_JVMTIEnv *env = (_Jv_JVMTIEnv *) _Jv_MallocUnchecked (sizeof (_Jv_JVMTIEnv)); env->p = &_Jv_JVMTI_Interface; + struct jvmti_env_list *element + = (struct jvmti_env_list *) _Jv_MallocUnchecked (sizeof (struct jvmti_env_list)); + element->env = env; + element->next = NULL; - { - JvSynchronize dummy (_envListLock); - struct jvmti_env_list *element - = (struct jvmti_env_list *) _Jv_MallocUnchecked (sizeof (struct jvmti_env_list)); - element->env = env; - element->next = NULL; - - if (_jvmtiEnvironments == NULL) - _jvmtiEnvironments = element; - else - { - struct jvmti_env_list *e; - for (e = _jvmtiEnvironments; e->next != NULL; e = e->next) - ; - e->next = element; - } - } + _envListLock->writeLock ()->lock (); + if (_jvmtiEnvironments == NULL) + _jvmtiEnvironments = element; + else + { + struct jvmti_env_list *e; + for (e = _jvmtiEnvironments; e->next != NULL; e = e->next) + ; + e->next = element; + } + _envListLock->writeLock ()->unlock (); /* Mark JVMTI active. This is used to force the interpreter to use either debugging or non-debugging code. Once JVMTI @@ -1769,7 +1779,8 @@ void _Jv_JVMTI_Init () { _jvmtiEnvironments = NULL; - _envListLock = new java::lang::Object (); + _envListLock + = new java::util::concurrent::locks::ReentrantReadWriteLock (); // No environments, so this should set all JVMTI:: members to false check_enabled_events (); @@ -2133,7 +2144,7 @@ _Jv_JVMTI_PostEvent (jvmtiEvent type, jthread event_thread, ...) va_list args; va_start (args, event_thread); - JvSynchronize dummy (_envListLock); + _envListLock->readLock ()->lock (); struct jvmti_env_list *e; FOREACH_ENVIRONMENT (e) { @@ -2149,6 +2160,6 @@ _Jv_JVMTI_PostEvent (jvmtiEvent type, jthread event_thread, ...) post_event (e->env, type, event_thread, args); } } - + _envListLock->readLock ()->unlock (); va_end (args); }