[coop] Make lock tracer os and coop mutex aware

diff --git a/mono/metadata/assembly.c b/mono/metadata/assembly.c
index af59d896488cd4709be93430e6affbe235f25d39..afa1827a7167b18d46deb3715cee4ae0fe0b2a91 100644 (file)
--- a/mono/metadata/assembly.c
+++ b/mono/metadata/assembly.c
@@ -759,13 +759,13 @@ mono_assemblies_init (void)
 static void
 mono_assembly_binding_lock (void)
 {
-       mono_locks_mutex_acquire (&assembly_binding_mutex, AssemblyBindingLock);
+       mono_locks_os_acquire (&assembly_binding_mutex, AssemblyBindingLock);
 }
 
 static void
 mono_assembly_binding_unlock (void)
 {
-       mono_locks_mutex_release (&assembly_binding_mutex, AssemblyBindingLock);
+       mono_locks_os_release (&assembly_binding_mutex, AssemblyBindingLock);
 }
 
 gboolean

diff --git a/mono/metadata/class.c b/mono/metadata/class.c
index 7950d105df63022c0f906fedfaff30fa6338f3e1..132c3a745cd4b70c880f867e1c2945890d26b301 100644 (file)
--- a/mono/metadata/class.c
+++ b/mono/metadata/class.c
@@ -103,13 +103,13 @@ typedef gboolean (*gclass_record_func) (MonoClass*, void*);
 static inline void
 classes_lock (void)
 {
-       mono_locks_acquire (&classes_mutex, ClassesLock);
+       mono_locks_os_acquire (&classes_mutex, ClassesLock);
 }
 
 static inline void
 classes_unlock (void)
 {
-       mono_locks_release (&classes_mutex, ClassesLock);
+       mono_locks_os_release (&classes_mutex, ClassesLock);
 }
 
 /* 

diff --git a/mono/metadata/domain-internals.h b/mono/metadata/domain-internals.h
index 63e8bfc3a54ba90a67884c012c10ceb736fe3a41..44b8bffaff3ba1d355f78eef5cc83ef0f27a1156 100644 (file)
--- a/mono/metadata/domain-internals.h
+++ b/mono/metadata/domain-internals.h
@@ -420,10 +420,10 @@ typedef struct  {
        const AssemblyVersionSet version_sets [4];
 } MonoRuntimeInfo;
 
-#define mono_domain_assemblies_lock(domain) mono_locks_acquire(&(domain)->assemblies_lock, DomainAssembliesLock)
-#define mono_domain_assemblies_unlock(domain) mono_locks_release(&(domain)->assemblies_lock, DomainAssembliesLock)
-#define mono_domain_jit_code_hash_lock(domain) mono_locks_acquire(&(domain)->jit_code_hash_lock, DomainJitCodeHashLock)
-#define mono_domain_jit_code_hash_unlock(domain) mono_locks_release(&(domain)->jit_code_hash_lock, DomainJitCodeHashLock)
+#define mono_domain_assemblies_lock(domain) mono_locks_os_acquire(&(domain)->assemblies_lock, DomainAssembliesLock)
+#define mono_domain_assemblies_unlock(domain) mono_locks_os_release(&(domain)->assemblies_lock, DomainAssembliesLock)
+#define mono_domain_jit_code_hash_lock(domain) mono_locks_os_acquire(&(domain)->jit_code_hash_lock, DomainJitCodeHashLock)
+#define mono_domain_jit_code_hash_unlock(domain) mono_locks_os_release(&(domain)->jit_code_hash_lock, DomainJitCodeHashLock)
 
 typedef MonoDomain* (*MonoLoadFunc) (const char *filename, const char *runtime_version);
 

diff --git a/mono/metadata/domain.c b/mono/metadata/domain.c
index 837cb790c1c3af231e67b8427a787902340cf9ea..59a1e27cae713187c87b97911cc2d478fd88dfa3 100644 (file)
--- a/mono/metadata/domain.c
+++ b/mono/metadata/domain.c
@@ -1963,12 +1963,12 @@ void
 mono_domain_lock (MonoDomain *domain)
 {
        MONO_TRY_BLOCKING;
-       mono_locks_acquire (&(domain)->lock, DomainLock);
+       mono_locks_os_acquire (&(domain)->lock, DomainLock);
        MONO_FINISH_TRY_BLOCKING;
 }
 
 void
 mono_domain_unlock (MonoDomain *domain)
 {
-       mono_locks_release (&(domain)->lock, DomainLock);
+       mono_locks_os_release (&(domain)->lock, DomainLock);
 }

diff --git a/mono/metadata/icall.c b/mono/metadata/icall.c
index 9cca87d7a86a85a8349d341f8f6a39739f9e906f..1da20150a8863e9b25586ea0ae2fd054e6674e81 100644 (file)
--- a/mono/metadata/icall.c
+++ b/mono/metadata/icall.c
@@ -7272,13 +7272,13 @@ mono_icall_init (void)
 static void
 mono_icall_lock (void)
 {
-       mono_locks_mutex_acquire (&icall_mutex, IcallLock);
+       mono_locks_os_acquire (&icall_mutex, IcallLock);
 }
 
 static void
 mono_icall_unlock (void)
 {
-       mono_locks_mutex_release (&icall_mutex, IcallLock);
+       mono_locks_os_release (&icall_mutex, IcallLock);
 }
 
 void

diff --git a/mono/metadata/image.c b/mono/metadata/image.c
index 38b9ddbe80f4d5211c474214f9a8ef19dd0233c4..038bc9d4aa001d75f779ebc48edf9f5aa17fe30e 100644 (file)
--- a/mono/metadata/image.c
+++ b/mono/metadata/image.c
@@ -2467,13 +2467,13 @@ g_slist_append_image (MonoImage *image, GSList *list, gpointer data)
 void
 mono_image_lock (MonoImage *image)
 {
-       mono_locks_acquire (&image->lock, ImageDataLock);
+       mono_locks_os_acquire (&image->lock, ImageDataLock);
 }
 
 void
 mono_image_unlock (MonoImage *image)
 {
-       mono_locks_release (&image->lock, ImageDataLock);
+       mono_locks_os_release (&image->lock, ImageDataLock);
 }
 
 

diff --git a/mono/metadata/loader.c b/mono/metadata/loader.c
index 5480cf82aabf29fc0b5bfb990c3c5e28d5a98661..73e6939c04fafc7da5898fb1ede68a107375e02e 100644 (file)
--- a/mono/metadata/loader.c
+++ b/mono/metadata/loader.c
@@ -82,13 +82,13 @@ static void dllmap_cleanup (void);
 static void
 global_loader_data_lock (void)
 {
-       mono_locks_acquire (&global_loader_data_mutex, LoaderGlobalDataLock);
+       mono_locks_os_acquire (&global_loader_data_mutex, LoaderGlobalDataLock);
 }
 
 static void
 global_loader_data_unlock (void)
 {
-       mono_locks_release (&global_loader_data_mutex, LoaderGlobalDataLock);
+       mono_locks_os_release (&global_loader_data_mutex, LoaderGlobalDataLock);
 }
 
 void
@@ -2541,7 +2541,7 @@ void
 mono_loader_lock (void)
 {
        MONO_TRY_BLOCKING;
-       mono_locks_acquire (&loader_mutex, LoaderLock);
+       mono_locks_os_acquire (&loader_mutex, LoaderLock);
        MONO_FINISH_TRY_BLOCKING;
                
        if (G_UNLIKELY (loader_lock_track_ownership)) {
@@ -2552,7 +2552,7 @@ mono_loader_lock (void)
 void
 mono_loader_unlock (void)
 {
-       mono_locks_release (&loader_mutex, LoaderLock);
+       mono_locks_os_release (&loader_mutex, LoaderLock);
        if (G_UNLIKELY (loader_lock_track_ownership)) {
                mono_native_tls_set_value (loader_lock_nest_id, GUINT_TO_POINTER (GPOINTER_TO_UINT (mono_native_tls_get_value (loader_lock_nest_id)) - 1));
        }

diff --git a/mono/metadata/lock-tracer.c b/mono/metadata/lock-tracer.c
index 4782ae90243c3ea6e9c7e21226f03f9f58896764..f0d2bca6ed49d12a513f5356d770a9790b2e53f3 100644 (file)
--- a/mono/metadata/lock-tracer.c
+++ b/mono/metadata/lock-tracer.c
@@ -31,8 +31,10 @@
  * 
  * To log more kind of locks just do the following:
  *     - add an entry into the RuntimeLocks enum
- *  - change mono_os_mutex_lock(mutex) to mono_locks_acquire (mutex, LockName)
- *  - change mono_os_mutex_unlock(mutex) to mono_locks_release (mutex, LockName)
+ *  - change mono_os_mutex_lock(mutex) to mono_locks_os_acquire (mutex, LockName)
+ *  - change mono_os_mutex_unlock(mutex) to mono_locks_os_release (mutex, LockName)
+ *  - change mono_coop_mutex_lock(mutex) to mono_locks_coop_acquire (mutex, LockName)
+ *  - change mono_coop_mutex_unlock(mutex) to mono_locks_coop_release (mutex, LockName)
  *  - change the decoder to understand the new lock kind.
  *
  * TODO:

diff --git a/mono/metadata/lock-tracer.h b/mono/metadata/lock-tracer.h
index ea201511979cd6e8540d21e74247c799f0792090..ee4ab3419504a593ece5443c857a74792ae186af 100644 (file)
--- a/mono/metadata/lock-tracer.h
+++ b/mono/metadata/lock-tracer.h
@@ -5,6 +5,7 @@
 #include <glib.h>
 
 #include "mono/utils/mono-os-mutex.h"
+#include "mono/utils/mono-coop-mutex.h"
 
 G_BEGIN_DECLS
 
@@ -39,25 +40,30 @@ void mono_locks_lock_released (RuntimeLocks kind, gpointer lock);
 
 #endif
 
-#define mono_locks_acquire(LOCK, NAME) do { \
-       mono_os_mutex_lock (LOCK); \
-       mono_locks_lock_acquired (NAME, LOCK); \
-} while (0)
-
-#define mono_locks_release(LOCK, NAME) do { \
-       mono_locks_lock_released (NAME, LOCK); \
-       mono_os_mutex_unlock (LOCK); \
-} while (0)
-
-#define mono_locks_mutex_acquire(LOCK, NAME) do { \
-       mono_os_mutex_lock (LOCK); \
-       mono_locks_lock_acquired (NAME, LOCK); \
-} while (0)
-
-#define mono_locks_mutex_release(LOCK, NAME) do { \
-       mono_locks_lock_released (NAME, LOCK); \
-       mono_os_mutex_unlock (LOCK); \
-} while (0)
+#define mono_locks_os_acquire(LOCK,NAME)       \
+       do {    \
+               mono_os_mutex_lock (LOCK);      \
+               mono_locks_lock_acquired (NAME, LOCK);  \
+       } while (0)
+
+#define mono_locks_os_release(LOCK,NAME)       \
+       do {    \
+               mono_locks_lock_released (NAME, LOCK);  \
+               mono_os_mutex_unlock (LOCK);    \
+       } while (0)
+
+#define mono_locks_coop_acquire(LOCK,NAME)     \
+       do {    \
+               mono_coop_mutex_lock (LOCK);    \
+               mono_locks_lock_acquired (NAME, LOCK);  \
+       } while (0)
+
+#define mono_locks_coop_release(LOCK,NAME)     \
+       do {    \
+               mono_locks_lock_released (NAME, LOCK);  \
+               mono_coop_mutex_unlock (LOCK);  \
+       } while (0)
+
 G_END_DECLS
 
 #endif /* __MONO_METADATA_LOCK_TRACER_H__ */

diff --git a/mono/metadata/marshal.c b/mono/metadata/marshal.c
index c26da5ae151b9db25e8b5aea3a371c0fd99e7eb0..31b8ac5e9b8e426637972644cbcf3dd7bc988930 100644 (file)
--- a/mono/metadata/marshal.c
+++ b/mono/metadata/marshal.c
@@ -66,8 +66,8 @@ enum {
  * The marshal lock is a non-recursive complex lock that sits below the domain lock in the
  * runtime locking latice. Which means it can take simple locks suck as the image lock.
  */
-#define mono_marshal_lock() mono_locks_acquire (&marshal_mutex, MarshalLock)
-#define mono_marshal_unlock() mono_locks_release (&marshal_mutex, MarshalLock)
+#define mono_marshal_lock() mono_locks_os_acquire (&marshal_mutex, MarshalLock)
+#define mono_marshal_unlock() mono_locks_os_release (&marshal_mutex, MarshalLock)
 static mono_mutex_t marshal_mutex;
 static gboolean marshal_mutex_initialized;
 

diff --git a/mono/metadata/threads.c b/mono/metadata/threads.c
index 8660f7681d1af4153958a147e27dc4c6cbb39886..240b9c81f77173fcdfcf21f9b8c69bd4605bc5b2 100644 (file)
--- a/mono/metadata/threads.c
+++ b/mono/metadata/threads.c
@@ -227,14 +227,14 @@ static void
 mono_threads_lock (void)
 {
        MONO_TRY_BLOCKING;
-       mono_locks_acquire (&threads_mutex, ThreadsLock);
+       mono_locks_os_acquire (&threads_mutex, ThreadsLock);
        MONO_FINISH_TRY_BLOCKING;
 }
 
 static void
 mono_threads_unlock (void)
 {
-       mono_locks_release (&threads_mutex, ThreadsLock);
+       mono_locks_os_release (&threads_mutex, ThreadsLock);
 }