* 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.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@121616 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index f94ac74..4b244ff 100644 (file)
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,5 +1,16 @@
 2007-02-05  Keith Seitz  <keiths@redhat.com>
 
+       * 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  <keiths@redhat.com>
+
        * gnu/classpath/jdwp/natVMVirtualMachine.cc
        (registerEvent): Implement EVENT_BREAKPOINT.
        (unregisterEvent): Likewise.

diff --git a/libjava/jvmti.cc b/libjava/jvmti.cc
index 2e32634..e14bd7c 100644 (file)
--- a/libjava/jvmti.cc
+++ b/libjava/jvmti.cc
@@ -27,7 +27,6 @@ details.  */
 
 #include <java/lang/Class.h>
 #include <java/lang/ClassLoader.h>
-#include <java/lang/Object.h>
 #include <java/lang/OutOfMemoryError.h>
 #include <java/lang/Thread.h>
 #include <java/lang/ThreadGroup.h>
@@ -37,6 +36,8 @@ details.  */
 #include <java/lang/reflect/Modifier.h>
 #include <java/util/Collection.h>
 #include <java/util/HashMap.h>
+#include <java/util/concurrent/locks/Lock.h>
+#include <java/util/concurrent/locks/ReentrantReadWriteLock.h>
 #include <java/net/URL.h>
 
 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<char *> (&e->env->callbacks) + offset;
-      void **callback = reinterpret_cast<void **> (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<char *> (&e->env->callbacks) + offset;
+         void **callback = reinterpret_cast<void **> (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);
 }