[coop] Use GC safe/unsafe macros inside the runtime

This allow the removal of MONO_(PREPARE|FINISH)BLOCKING and MONO(PREPARE|FINISH)_RESET_BLOCKING, which were not explicit in their intent, leading to confusion. This also harmonize how the product and the runtime transition between thread states.

diff --git a/mono/metadata/appdomain.c b/mono/metadata/appdomain.c
index 58acb87c8b85e76b1f0f61a89ce03cf5ee80d11f..b8be86856554388123c952a9a4036e2fac283153 100644 (file)
--- a/mono/metadata/appdomain.c
+++ b/mono/metadata/appdomain.c
@@ -2537,9 +2537,9 @@ guarded_wait (HANDLE handle, guint32 timeout, gboolean alertable)
 {
        guint32 result;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        result = WaitForSingleObjectEx (handle, timeout, alertable);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        return result;
 }

diff --git a/mono/metadata/file-io.c b/mono/metadata/file-io.c
index c10b1fee8d934b8249c8ca70b32497e0c5a174dc..0ee01d806d2675dcbed94d83deefe255c12820ff 100644 (file)
--- a/mono/metadata/file-io.c
+++ b/mono/metadata/file-io.c
@@ -270,7 +270,7 @@ MonoBoolean
 ves_icall_System_IO_MonoIO_CreateDirectory (MonoString *path, gint32 *error)
 {
        gboolean ret;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        
        *error=ERROR_SUCCESS;
        
@@ -279,7 +279,7 @@ ves_icall_System_IO_MonoIO_CreateDirectory (MonoString *path, gint32 *error)
                *error=GetLastError ();
        }
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return(ret);
 }
 
@@ -287,7 +287,7 @@ MonoBoolean
 ves_icall_System_IO_MonoIO_RemoveDirectory (MonoString *path, gint32 *error)
 {
        gboolean ret;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        
        *error=ERROR_SUCCESS;
        
@@ -296,7 +296,7 @@ ves_icall_System_IO_MonoIO_RemoveDirectory (MonoString *path, gint32 *error)
                *error=GetLastError ();
        }
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return(ret);
 }
 
@@ -404,9 +404,9 @@ ves_icall_System_IO_MonoIO_GetFileSystemEntries (MonoString *path,
        
        *ioerror = ERROR_SUCCESS;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        names = get_filesystem_entries (mono_string_chars (path), mono_string_chars (path_with_pattern), attrs, mask, ioerror);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if (!names) {
                // If there's no array and no error, then return an empty array.
@@ -531,14 +531,14 @@ ves_icall_System_IO_MonoIO_FindClose (gpointer handle)
        IncrementalFind *ifh = (IncrementalFind *)handle;
        gint32 error;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        if (FindClose (ifh->find_handle) == FALSE){
                error = GetLastError ();
        } else
                error = ERROR_SUCCESS;
        g_free (ifh->utf8_path);
        g_free (ifh);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        return error;
 }
@@ -602,7 +602,7 @@ ves_icall_System_IO_MonoIO_MoveFile (MonoString *path, MonoString *dest,
                                     gint32 *error)
 {
        gboolean ret;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        
        *error=ERROR_SUCCESS;
 
@@ -611,7 +611,7 @@ ves_icall_System_IO_MonoIO_MoveFile (MonoString *path, MonoString *dest,
                *error=GetLastError ();
        }
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return(ret);
 }
 
@@ -623,7 +623,7 @@ ves_icall_System_IO_MonoIO_ReplaceFile (MonoString *sourceFileName, MonoString *
        gboolean ret;
        gunichar2 *utf16_sourceFileName = NULL, *utf16_destinationFileName = NULL, *utf16_destinationBackupFileName = NULL;
        guint32 replaceFlags = REPLACEFILE_WRITE_THROUGH;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        if (sourceFileName)
                utf16_sourceFileName = mono_string_chars (sourceFileName);
@@ -642,7 +642,7 @@ ves_icall_System_IO_MonoIO_ReplaceFile (MonoString *sourceFileName, MonoString *
        if (ret == FALSE)
                *error = GetLastError ();
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return ret;
 }
 
@@ -651,7 +651,7 @@ ves_icall_System_IO_MonoIO_CopyFile (MonoString *path, MonoString *dest,
                                     MonoBoolean overwrite, gint32 *error)
 {
        gboolean ret;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        
        *error=ERROR_SUCCESS;
        
@@ -660,7 +660,7 @@ ves_icall_System_IO_MonoIO_CopyFile (MonoString *path, MonoString *dest,
                *error=GetLastError ();
        }
        
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return(ret);
 }
 
@@ -668,7 +668,7 @@ MonoBoolean
 ves_icall_System_IO_MonoIO_DeleteFile (MonoString *path, gint32 *error)
 {
        gboolean ret;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        
        *error=ERROR_SUCCESS;
        
@@ -677,7 +677,7 @@ ves_icall_System_IO_MonoIO_DeleteFile (MonoString *path, gint32 *error)
                *error=GetLastError ();
        }
        
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return(ret);
 }
 
@@ -685,7 +685,7 @@ gint32
 ves_icall_System_IO_MonoIO_GetFileAttributes (MonoString *path, gint32 *error)
 {
        gint32 ret;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        *error=ERROR_SUCCESS;
        
@@ -702,7 +702,7 @@ ves_icall_System_IO_MonoIO_GetFileAttributes (MonoString *path, gint32 *error)
                *error=GetLastError ();
        }
        
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return(ret);
 }
 
@@ -711,7 +711,7 @@ ves_icall_System_IO_MonoIO_SetFileAttributes (MonoString *path, gint32 attrs,
                                              gint32 *error)
 {
        gboolean ret;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        
        *error=ERROR_SUCCESS;
        
@@ -721,7 +721,7 @@ ves_icall_System_IO_MonoIO_SetFileAttributes (MonoString *path, gint32 attrs,
                *error=GetLastError ();
        }
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return(ret);
 }
 
@@ -729,7 +729,7 @@ gint32
 ves_icall_System_IO_MonoIO_GetFileType (HANDLE handle, gint32 *error)
 {
        gboolean ret;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        *error=ERROR_SUCCESS;
        
@@ -741,7 +741,7 @@ ves_icall_System_IO_MonoIO_GetFileType (HANDLE handle, gint32 *error)
                *error=GetLastError ();
        }
        
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return(ret);
 }
 
@@ -751,7 +751,7 @@ ves_icall_System_IO_MonoIO_GetFileStat (MonoString *path, MonoIOStat *stat,
 {
        gboolean result;
        WIN32_FILE_ATTRIBUTE_DATA data;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        *error=ERROR_SUCCESS;
        
@@ -764,7 +764,7 @@ ves_icall_System_IO_MonoIO_GetFileStat (MonoString *path, MonoIOStat *stat,
                memset (stat, 0, sizeof (MonoIOStat));
        }
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return result;
 }
 
@@ -776,7 +776,7 @@ ves_icall_System_IO_MonoIO_Open (MonoString *filename, gint32 mode,
        HANDLE ret;
        int attributes, attrs;
        gunichar2 *chars;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        chars = mono_string_chars (filename);   
        *error=ERROR_SUCCESS;
@@ -821,7 +821,7 @@ ves_icall_System_IO_MonoIO_Open (MonoString *filename, gint32 mode,
                *error=GetLastError ();
        } 
        
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return(ret);
 }
 
@@ -829,7 +829,7 @@ MonoBoolean
 ves_icall_System_IO_MonoIO_Close (HANDLE handle, gint32 *error)
 {
        gboolean ret;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        *error=ERROR_SUCCESS;
        
@@ -838,7 +838,7 @@ ves_icall_System_IO_MonoIO_Close (HANDLE handle, gint32 *error)
                *error=GetLastError ();
        }
        
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return(ret);
 }
 
@@ -862,9 +862,9 @@ ves_icall_System_IO_MonoIO_Read (HANDLE handle, MonoArray *dest,
 
        buffer = mono_array_addr (dest, guchar, dest_offset);
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        result = ReadFile (handle, buffer, count, &n, NULL);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if (!result) {
                *error=GetLastError ();
@@ -893,9 +893,9 @@ ves_icall_System_IO_MonoIO_Write (HANDLE handle, MonoArray *src,
        }
        
        buffer = mono_array_addr (src, guchar, src_offset);
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        result = WriteFile (handle, buffer, count, &n, NULL);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if (!result) {
                *error=GetLastError ();
@@ -910,7 +910,7 @@ ves_icall_System_IO_MonoIO_Seek (HANDLE handle, gint64 offset, gint32 origin,
                                 gint32 *error)
 {
        gint32 offset_hi;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        *error=ERROR_SUCCESS;
        
@@ -922,7 +922,7 @@ ves_icall_System_IO_MonoIO_Seek (HANDLE handle, gint64 offset, gint32 origin,
                *error=GetLastError ();
        }
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return offset | ((gint64)offset_hi << 32);
 }
 
@@ -930,7 +930,7 @@ MonoBoolean
 ves_icall_System_IO_MonoIO_Flush (HANDLE handle, gint32 *error)
 {
        gboolean ret;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        *error=ERROR_SUCCESS;
        
@@ -939,7 +939,7 @@ ves_icall_System_IO_MonoIO_Flush (HANDLE handle, gint32 *error)
                *error=GetLastError ();
        }
        
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return(ret);
 }
 
@@ -948,7 +948,7 @@ ves_icall_System_IO_MonoIO_GetLength (HANDLE handle, gint32 *error)
 {
        gint64 length;
        guint32 length_hi;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        *error=ERROR_SUCCESS;
        
@@ -957,7 +957,7 @@ ves_icall_System_IO_MonoIO_GetLength (HANDLE handle, gint32 *error)
                *error=GetLastError ();
        }
        
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return length | ((gint64)length_hi << 32);
 }
 
@@ -1019,7 +1019,7 @@ ves_icall_System_IO_MonoIO_SetFileTime (HANDLE handle, gint64 creation_time,
        const FILETIME *creation_filetime;
        const FILETIME *last_access_filetime;
        const FILETIME *last_write_filetime;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        *error=ERROR_SUCCESS;
        
@@ -1043,7 +1043,7 @@ ves_icall_System_IO_MonoIO_SetFileTime (HANDLE handle, gint64 creation_time,
                *error=GetLastError ();
        }
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return(ret);
 }
 
@@ -1075,9 +1075,9 @@ ves_icall_System_IO_MonoIO_CreatePipe (HANDLE *read_handle, HANDLE *write_handle
        attr.bInheritHandle=TRUE;
        attr.lpSecurityDescriptor=NULL;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        ret=CreatePipe (read_handle, write_handle, &attr, 0);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if(ret==FALSE) {
                *error = GetLastError ();
@@ -1095,9 +1095,9 @@ ves_icall_System_IO_MonoIO_DuplicateHandle (HANDLE source_process_handle, HANDLE
        /* This is only used on Windows */
        gboolean ret;
        
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        ret=DuplicateHandle (source_process_handle, source_handle, target_process_handle, target_handle, access, inherit, options);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if(ret==FALSE) {
                *error = GetLastError ();
@@ -1196,7 +1196,7 @@ void ves_icall_System_IO_MonoIO_Lock (HANDLE handle, gint64 position,
                                      gint64 length, gint32 *error)
 {
        gboolean ret;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        
        *error=ERROR_SUCCESS;
        
@@ -1206,14 +1206,14 @@ void ves_icall_System_IO_MonoIO_Lock (HANDLE handle, gint64 position,
                *error = GetLastError ();
        }
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 }
 
 void ves_icall_System_IO_MonoIO_Unlock (HANDLE handle, gint64 position,
                                        gint64 length, gint32 *error)
 {
        gboolean ret;
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        
        *error=ERROR_SUCCESS;
        
@@ -1223,7 +1223,7 @@ void ves_icall_System_IO_MonoIO_Unlock (HANDLE handle, gint64 position,
                *error = GetLastError ();
        }
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 }
 
 //Support for io-layer free mmap'd files.
@@ -1237,7 +1237,7 @@ mono_filesize_from_path (MonoString *string)
        gint64 res;
        char *path = mono_string_to_utf8 (string);
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        if (stat (path, &buf) == -1)
                res = -1;
        else
@@ -1245,7 +1245,7 @@ mono_filesize_from_path (MonoString *string)
 
        g_free (path);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return res;
 }
 
@@ -1255,9 +1255,9 @@ mono_filesize_from_fd (int fd)
        struct stat buf;
        int res;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        res = fstat (fd, &buf);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        
        if (res == -1)
                return (gint64)-1;

diff --git a/mono/metadata/filewatcher.c b/mono/metadata/filewatcher.c
index eb1827a0c6055f863341ad2c12cdcf55b11ec600..d87e158776704977c890c70bbce699ab8854ff53 100644 (file)
--- a/mono/metadata/filewatcher.c
+++ b/mono/metadata/filewatcher.c
@@ -231,9 +231,9 @@ ves_icall_System_IO_KqueueMonitor_kevent_notimeout (int *kq_ptr, gpointer change
                return -1;
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        res = kevent (*kq_ptr, changelist, nchanges, eventlist, nevents, NULL);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        mono_thread_info_uninstall_interrupt (&interrupted);
 

diff --git a/mono/metadata/gc.c b/mono/metadata/gc.c
index 107714c98f51d0221bf6c7e6213182c6bab87b18..6050c0dc4b727581e0ba3dd751c25b15f7421de4 100644 (file)
--- a/mono/metadata/gc.c
+++ b/mono/metadata/gc.c
@@ -85,9 +85,9 @@ guarded_wait (HANDLE handle, guint32 timeout, gboolean alertable)
 {
        guint32 result;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        result = WaitForSingleObjectEx (handle, timeout, alertable);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        return result;
 }

diff --git a/mono/metadata/marshal.c b/mono/metadata/marshal.c
index 27a7a5a1f165c1eb35af33ee2ec5be6b32048d42..4d7f6cb95a1069c95ce4ad51e24fddfc9f19cece 100644 (file)
--- a/mono/metadata/marshal.c
+++ b/mono/metadata/marshal.c
@@ -322,8 +322,8 @@ mono_marshal_init (void)
                register_icall (mono_gchandle_new, "mono_gchandle_new", "uint32 object bool", TRUE);
                register_icall (mono_marshal_isinst_with_cache, "mono_marshal_isinst_with_cache", "object object ptr ptr", FALSE);
                register_icall (mono_marshal_ftnptr_eh_callback, "mono_marshal_ftnptr_eh_callback", "void uint32", TRUE);
-               register_icall (mono_threads_prepare_blocking_unbalanced, "mono_threads_prepare_blocking_unbalanced", "ptr ptr", TRUE);
-               register_icall (mono_threads_finish_blocking_unbalanced, "mono_threads_finish_blocking_unbalanced", "void ptr ptr", TRUE);
+               register_icall (mono_threads_enter_gc_safe_region_unbalanced, "mono_threads_enter_gc_safe_region_unbalanced", "ptr ptr", TRUE);
+               register_icall (mono_threads_exit_gc_safe_region_unbalanced, "mono_threads_exit_gc_safe_region_unbalanced", "void ptr ptr", TRUE);
 
                mono_cominterop_init ();
                mono_remoting_init ();
@@ -7329,11 +7329,11 @@ mono_marshal_emit_native_wrapper (MonoImage *image, MonoMethodBuilder *mb, MonoM
        }
 
        /*
-        * cookie = mono_threads_prepare_blocking_unbalanced (ref dummy);
+        * cookie = mono_threads_enter_gc_safe_region_unbalanced (ref dummy);
         *
         * ret = method (...);
         *
-        * mono_threads_finish_blocking_unbalanced (cookie, ref dummy);
+        * mono_threads_exit_gc_safe_region_unbalanced (cookie, ref dummy);
         *
         * <interrupt check>
         *
@@ -7372,7 +7372,7 @@ mono_marshal_emit_native_wrapper (MonoImage *image, MonoMethodBuilder *mb, MonoM
                }
 
                mono_mb_emit_ldloc_addr (mb, coop_gc_stack_dummy);
-               mono_mb_emit_icall (mb, mono_threads_prepare_blocking_unbalanced);
+               mono_mb_emit_icall (mb, mono_threads_enter_gc_safe_region_unbalanced);
                mono_mb_emit_stloc (mb, coop_gc_var);
        }
 
@@ -7423,7 +7423,7 @@ mono_marshal_emit_native_wrapper (MonoImage *image, MonoMethodBuilder *mb, MonoM
        if (mono_threads_is_coop_enabled ()) {
                mono_mb_emit_ldloc (mb, coop_gc_var);
                mono_mb_emit_ldloc_addr (mb, coop_gc_stack_dummy);
-               mono_mb_emit_icall (mb, mono_threads_finish_blocking_unbalanced);
+               mono_mb_emit_icall (mb, mono_threads_exit_gc_safe_region_unbalanced);
        }
 
        /* Set LastError if needed */
@@ -11840,7 +11840,7 @@ ftnptr_eh_callback_default (guint32 gchandle)
 
        g_assert (gchandle >= 0);
 
-       mono_threads_reset_blocking_start_unbalanced (&stackdata);
+       mono_threads_enter_gc_unsafe_region_unbalanced (&stackdata);
 
        exc = (MonoException*) mono_gchandle_get_target (gchandle);
 

diff --git a/mono/metadata/monitor.c b/mono/metadata/monitor.c
index 0fe4b593d58e782171e329439a29745266bdd87f..6cf9691777ea783631f39c7cac24c239cd180a7f 100644 (file)
--- a/mono/metadata/monitor.c
+++ b/mono/metadata/monitor.c
@@ -881,9 +881,9 @@ retry_contended:
         * We pass TRUE instead of allow_interruption since we have to check for the
         * StopRequested case below.
         */
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        ret = WaitForSingleObjectEx (mon->entry_sem, waitms, TRUE);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        mono_thread_clr_state (thread, ThreadState_WaitSleepJoin);
        
@@ -1279,9 +1279,9 @@ ves_icall_System_Threading_Monitor_Monitor_wait (MonoObject *obj, guint32 ms)
         * is private to this thread.  Therefore even if the event was
         * signalled before we wait, we still succeed.
         */
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        ret = WaitForSingleObjectEx (event, ms, TRUE);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        /* Reset the thread state fairly early, so we don't have to worry
         * about the monitor error checking
@@ -1304,9 +1304,9 @@ ves_icall_System_Threading_Monitor_Monitor_wait (MonoObject *obj, guint32 ms)
                /* Poll the event again, just in case it was signalled
                 * while we were trying to regain the monitor lock
                 */
-               MONO_PREPARE_BLOCKING;
+               MONO_ENTER_GC_SAFE;
                ret = WaitForSingleObjectEx (event, 0, FALSE);
-               MONO_FINISH_BLOCKING;
+               MONO_EXIT_GC_SAFE;
        }
 
        /* Pulse will have popped our event from the queue if it signalled

diff --git a/mono/metadata/object.c b/mono/metadata/object.c
index f0c98d741eb8ae59cd9e5baaafeda7f5a85c047f..fa68faab7123b38defc9d0daa800c10e23ad4dbc 100644 (file)
--- a/mono/metadata/object.c
+++ b/mono/metadata/object.c
@@ -2892,11 +2892,11 @@ do_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoObject **ex
        if (mono_profiler_get_events () & MONO_PROFILE_METHOD_EVENTS)
                mono_profiler_method_start_invoke (method);
 
-       MONO_PREPARE_RESET_BLOCKING;
+       MONO_ENTER_GC_UNSAFE;
 
        result = callbacks.runtime_invoke (method, obj, params, exc, error);
 
-       MONO_FINISH_RESET_BLOCKING;
+       MONO_EXIT_GC_UNSAFE;
 
        if (mono_profiler_get_events () & MONO_PROFILE_METHOD_EVENTS)
                mono_profiler_method_end_invoke (method);
@@ -3117,10 +3117,10 @@ mono_method_get_unmanaged_thunk (MonoMethod *method)
 
        g_assert (!mono_threads_is_coop_enabled ());
 
-       MONO_PREPARE_RESET_BLOCKING;
+       MONO_ENTER_GC_UNSAFE;
        method = mono_marshal_get_thunk_invoke_wrapper (method);
        res = mono_compile_method (method);
-       MONO_FINISH_RESET_BLOCKING;
+       MONO_EXIT_GC_UNSAFE;
 
        return res;
 }

diff --git a/mono/metadata/reflection.c b/mono/metadata/reflection.c
index f13a42d5d93046ba52c7616d8ad1e542c6da2b3d..4a651b09f18df10603a8e3e6b20011f145f75a5d 100644 (file)
--- a/mono/metadata/reflection.c
+++ b/mono/metadata/reflection.c
@@ -294,9 +294,9 @@ mono_reflection_init (void)
 static inline void
 dynamic_image_lock (MonoDynamicImage *image)
 {
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        mono_image_lock ((MonoImage*)image);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 }
 
 static inline void

diff --git a/mono/metadata/socket-io.c b/mono/metadata/socket-io.c
index 15ee378dd8576a6076899a01dbec3f99a7cfdda5..eb272c241d6a56f46d0c307ab2aa1047c33005cf 100644 (file)
--- a/mono/metadata/socket-io.c
+++ b/mono/metadata/socket-io.c
@@ -695,9 +695,9 @@ ves_icall_System_Net_Sockets_Socket_Close_internal (SOCKET sock, gint32 *werror)
         * polling system does not notify when the socket is closed */
        mono_threadpool_ms_io_remove_socket (GPOINTER_TO_INT (sock));
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        closesocket (sock);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 }
 
 gint32
@@ -758,7 +758,7 @@ ves_icall_System_Net_Sockets_Socket_Accept_internal (SOCKET sock, gint32 *werror
                return NULL;
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
 #ifdef HOST_WIN32
        {
@@ -771,7 +771,7 @@ ves_icall_System_Net_Sockets_Socket_Accept_internal (SOCKET sock, gint32 *werror
        newsock = _wapi_accept (sock, NULL, 0);
 #endif
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        mono_thread_info_uninstall_interrupt (&interrupted);
        if (interrupted) {
@@ -794,11 +794,11 @@ ves_icall_System_Net_Sockets_Socket_Listen_internal(SOCKET sock, guint32 backlog
        
        *werror = 0;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        ret = _wapi_listen (sock, backlog);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if (ret == SOCKET_ERROR)
                *werror = WSAGetLastError ();
@@ -991,11 +991,11 @@ ves_icall_System_Net_Sockets_Socket_LocalEndPoint_internal (SOCKET sock, gint32
        }
        sa = (salen <= 128) ? (gchar *)alloca (salen) : (gchar *)g_malloc0 (salen);
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        ret = _wapi_getsockname (sock, (struct sockaddr *)sa, &salen);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        
        if (ret == SOCKET_ERROR) {
                *werror = WSAGetLastError ();
@@ -1033,11 +1033,11 @@ ves_icall_System_Net_Sockets_Socket_RemoteEndPoint_internal (SOCKET sock, gint32
        sa = (salen <= 128) ? (gchar *)alloca (salen) : (gchar *)g_malloc0 (salen);
        /* Note: linux returns just 2 for AF_UNIX. Always. */
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        ret = _wapi_getpeername (sock, (struct sockaddr *)sa, &salen);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if (ret == SOCKET_ERROR) {
                *werror = WSAGetLastError ();
@@ -1250,11 +1250,11 @@ ves_icall_System_Net_Sockets_Socket_Poll_internal (SOCKET sock, gint mode,
                        return FALSE;
                }
 
-               MONO_PREPARE_BLOCKING;
+               MONO_ENTER_GC_SAFE;
 
                ret = mono_poll (pfds, 1, timeout);
 
-               MONO_FINISH_BLOCKING;
+               MONO_EXIT_GC_SAFE;
 
                mono_thread_info_uninstall_interrupt (&interrupted);
                if (interrupted) {
@@ -1329,11 +1329,11 @@ ves_icall_System_Net_Sockets_Socket_Connect_internal (SOCKET sock, MonoObject *s
                return;
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        ret = _wapi_connect (sock, sa, sa_size);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        mono_thread_info_uninstall_interrupt (&interrupted);
        if (interrupted) {
@@ -1376,7 +1376,7 @@ ves_icall_System_Net_Sockets_Socket_Disconnect_internal (SOCKET sock, MonoBoolea
 
        LOGDEBUG (g_message("%s: disconnecting from socket %p (reuse %d)", __func__, sock, reuse));
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        /* I _think_ the extension function pointers need to be looked
         * up for each socket.  FIXME: check the best way to store
@@ -1386,7 +1386,7 @@ ves_icall_System_Net_Sockets_Socket_Disconnect_internal (SOCKET sock, MonoBoolea
        ret = WSAIoctl (sock, SIO_GET_EXTENSION_FUNCTION_POINTER, (gchar *)&disco_guid, sizeof (GUID),
                                        (gchar *)&_wapi_disconnectex, sizeof (void *), &output_bytes, NULL, NULL);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if (ret != 0) {
                /* make sure that WSAIoctl didn't put crap in the
@@ -1394,7 +1394,7 @@ ves_icall_System_Net_Sockets_Socket_Disconnect_internal (SOCKET sock, MonoBoolea
                 */
                _wapi_disconnectex = NULL;
 
-               MONO_PREPARE_BLOCKING;
+               MONO_ENTER_GC_SAFE;
 
                /*
                 * Use the SIO_GET_EXTENSION_FUNCTION_POINTER to
@@ -1407,7 +1407,7 @@ ves_icall_System_Net_Sockets_Socket_Disconnect_internal (SOCKET sock, MonoBoolea
                ret = WSAIoctl (sock, SIO_GET_EXTENSION_FUNCTION_POINTER, (gchar *)&trans_guid, sizeof(GUID),
                                (gchar *)&_wapi_transmitfile, sizeof(void *), &output_bytes, NULL, NULL);
 
-               MONO_FINISH_BLOCKING;
+               MONO_EXIT_GC_SAFE;
 
                if (ret != 0)
                        _wapi_transmitfile = NULL;
@@ -1419,7 +1419,7 @@ ves_icall_System_Net_Sockets_Socket_Disconnect_internal (SOCKET sock, MonoBoolea
                return;
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        if (_wapi_disconnectex != NULL) {
                if (!_wapi_disconnectex (sock, NULL, TF_REUSE_SOCKET, 0))
@@ -1431,7 +1431,7 @@ ves_icall_System_Net_Sockets_Socket_Disconnect_internal (SOCKET sock, MonoBoolea
                *werror = ERROR_NOT_SUPPORTED;
        }
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        mono_thread_info_uninstall_interrupt (&interrupted);
        if (interrupted)
@@ -1466,7 +1466,7 @@ ves_icall_System_Net_Sockets_Socket_Receive_internal (SOCKET sock, MonoArray *bu
        if (interrupted)
                return 0;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
 #ifdef HOST_WIN32
        {
@@ -1478,7 +1478,7 @@ ves_icall_System_Net_Sockets_Socket_Receive_internal (SOCKET sock, MonoArray *bu
        ret = _wapi_recv (sock, buf, count, recvflags);
 #endif
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        mono_thread_info_uninstall_interrupt (&interrupted);
        if (interrupted) {
@@ -1520,11 +1520,11 @@ ves_icall_System_Net_Sockets_Socket_Receive_array_internal (SOCKET sock, MonoArr
                return 0;
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        ret = WSARecv (sock, wsabufs, count, &recv, &recvflags, NULL, NULL);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        mono_thread_info_uninstall_interrupt (&interrupted);
        if (interrupted) {
@@ -1581,11 +1581,11 @@ ves_icall_System_Net_Sockets_Socket_ReceiveFrom_internal (SOCKET sock, MonoArray
                return 0;
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        ret = _wapi_recvfrom (sock, buf, count, recvflags, sa, &sa_size);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        mono_thread_info_uninstall_interrupt (&interrupted);
        if (interrupted) {
@@ -1653,11 +1653,11 @@ ves_icall_System_Net_Sockets_Socket_Send_internal (SOCKET sock, MonoArray *buffe
                return 0;
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        ret = _wapi_send (sock, buf, count, sendflags);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        mono_thread_info_uninstall_interrupt (&interrupted);
        if (interrupted) {
@@ -1699,11 +1699,11 @@ ves_icall_System_Net_Sockets_Socket_Send_array_internal (SOCKET sock, MonoArray
                return 0;
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        ret = WSASend (sock, wsabufs, count, &sent, sendflags, NULL, NULL);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        mono_thread_info_uninstall_interrupt (&interrupted);
        if (interrupted) {
@@ -1766,11 +1766,11 @@ ves_icall_System_Net_Sockets_Socket_SendTo_internal (SOCKET sock, MonoArray *buf
                return 0;
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        ret = _wapi_sendto (sock, buf, count, sendflags, sa, sa_size);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        mono_thread_info_uninstall_interrupt (&interrupted);
        if (interrupted) {
@@ -1857,11 +1857,11 @@ ves_icall_System_Net_Sockets_Socket_Select_internal (MonoArray **sockets, gint32
                        return;
                }
 
-               MONO_PREPARE_BLOCKING;
+               MONO_ENTER_GC_SAFE;
 
                ret = mono_poll (pfds, nfds, timeout);
 
-               MONO_FINISH_BLOCKING;
+               MONO_EXIT_GC_SAFE;
 
                mono_thread_info_uninstall_interrupt (&interrupted);
                if (interrupted) {
@@ -2003,7 +2003,7 @@ ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal (SOCKET sock, g
                return;
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        /* No need to deal with MulticastOption names here, because
         * you cant getsockopt AddMembership or DropMembership (the
@@ -2030,7 +2030,7 @@ ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal (SOCKET sock, g
                ret = _wapi_getsockopt (sock, system_level, system_name, &val, &valsize);
        }
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if (ret == SOCKET_ERROR) {
                *werror = WSAGetLastError ();
@@ -2142,11 +2142,11 @@ ves_icall_System_Net_Sockets_Socket_GetSocketOption_arr_internal (SOCKET sock, g
        valsize = mono_array_length (*byte_val);
        buf = mono_array_addr (*byte_val, guchar, 0);
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        ret = _wapi_getsockopt (sock, system_level, system_name, buf, &valsize);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if (ret == SOCKET_ERROR)
                *werror = WSAGetLastError ();
@@ -2446,12 +2446,12 @@ ves_icall_System_Net_Sockets_Socket_Shutdown_internal (SOCKET sock, gint32 how,
                return;
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        /* Currently, the values for how (recv=0, send=1, both=2) match the BSD API */
        ret = _wapi_shutdown (sock, how);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        mono_thread_info_uninstall_interrupt (&interrupted);
        if (interrupted) {
@@ -2493,11 +2493,11 @@ ves_icall_System_Net_Sockets_Socket_IOControl_internal (SOCKET sock, gint32 code
                o_len = mono_array_length (output);
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        ret = WSAIoctl (sock, code, i_buffer, i_len, o_buffer, o_len, &output_bytes, NULL, NULL);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if (ret == SOCKET_ERROR) {
                *werror = WSAGetLastError ();
@@ -2712,7 +2712,7 @@ ves_icall_System_Net_Dns_GetHostByAddr_internal (MonoString *addr, MonoString **
 
        g_free (address);
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        switch (family) {
        case AF_INET: {
@@ -2733,7 +2733,7 @@ ves_icall_System_Net_Dns_GetHostByAddr_internal (MonoString *addr, MonoString **
                g_assert_not_reached ();
        }
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if (!ret)
                return FALSE;
@@ -2804,11 +2804,11 @@ ves_icall_System_Net_Sockets_Socket_SendFile_internal (SOCKET sock, MonoString *
                return FALSE;
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        ret = TransmitFile (sock, file, 0, 0, NULL, &buffers, flags);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        mono_thread_info_uninstall_interrupt (&interrupted);
        if (interrupted) {
@@ -2817,11 +2817,11 @@ ves_icall_System_Net_Sockets_Socket_SendFile_internal (SOCKET sock, MonoString *
                return FALSE;
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        CloseHandle (file);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        return ret;
 }

diff --git a/mono/metadata/threadpool-ms.c b/mono/metadata/threadpool-ms.c
index 69ade32e593ef5fc5db50665d5924f1069595dcb..59095d9122c21a9c21f93cdf888af001f499f012 100644 (file)
--- a/mono/metadata/threadpool-ms.c
+++ b/mono/metadata/threadpool-ms.c
@@ -1401,9 +1401,9 @@ mono_threadpool_ms_end_invoke (MonoAsyncResult *ares, MonoArray **out_args, Mono
                        MONO_OBJECT_SETREF (ares, handle, (MonoObject*) wait_handle);
                }
                mono_monitor_exit ((MonoObject*) ares);
-               MONO_PREPARE_BLOCKING;
+               MONO_ENTER_GC_SAFE;
                WaitForSingleObjectEx (wait_event, INFINITE, TRUE);
-               MONO_FINISH_BLOCKING;
+               MONO_EXIT_GC_SAFE;
        }
 
        ac = (MonoAsyncCall*) ares->object_data;
@@ -1461,9 +1461,9 @@ mono_threadpool_ms_remove_domain_jobs (MonoDomain *domain, int timeout)
                        }
                }
 
-               MONO_PREPARE_BLOCKING;
+               MONO_ENTER_GC_SAFE;
                WaitForSingleObject (sem, timeout != -1 ? end - now : timeout);
-               MONO_FINISH_BLOCKING;
+               MONO_EXIT_GC_SAFE;
        }
 
        domain->cleanup_semaphore = NULL;

diff --git a/mono/metadata/threads.c b/mono/metadata/threads.c
index c7efeafec3a01c3bf5c7ef37b745d24479584a08..253e9c32c3f4938dc73ab6b1caf66fca406b2d53 100644 (file)
--- a/mono/metadata/threads.c
+++ b/mono/metadata/threads.c
@@ -882,9 +882,9 @@ create_thread (MonoThread *thread, MonoInternalThread *internal, StartInfo *star
                 */
                THREAD_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") waiting for thread %p (%"G_GSIZE_FORMAT") to start", __func__, mono_native_thread_id_get (), internal, (gsize)internal->tid));
 
-               MONO_PREPARE_BLOCKING;
+               MONO_ENTER_GC_SAFE;
                WaitForSingleObjectEx (internal->start_notify, INFINITE, FALSE);
-               MONO_FINISH_BLOCKING;
+               MONO_EXIT_GC_SAFE;
 
                CloseHandle (internal->start_notify);
                internal->start_notify = NULL;
@@ -1560,9 +1560,9 @@ ves_icall_System_Threading_Thread_Join_internal(MonoThread *this_obj, int ms)
        
        mono_thread_set_state (cur_thread, ThreadState_WaitSleepJoin);
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        ret=WaitForSingleObjectEx (handle, ms, TRUE);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        mono_thread_clr_state (cur_thread, ThreadState_WaitSleepJoin);
        
@@ -1588,12 +1588,12 @@ mono_wait_uninterrupted (MonoInternalThread *thread, gboolean multiple, guint32
 
        start = (ms == -1) ? 0 : mono_100ns_ticks ();
        do {
-               MONO_PREPARE_BLOCKING;
+               MONO_ENTER_GC_SAFE;
                        if (multiple)
                        ret = WaitForMultipleObjectsEx (numhandles, handles, waitall, wait, alertable);
                else
                        ret = WaitForSingleObjectEx (handles [0], ms, alertable);
-               MONO_FINISH_BLOCKING;
+               MONO_EXIT_GC_SAFE;
 
                if (ret != WAIT_IO_COMPLETION)
                        break;
@@ -1738,9 +1738,9 @@ ves_icall_System_Threading_WaitHandle_SignalAndWait_Internal (HANDLE toSignal, H
 
        mono_thread_set_state (thread, ThreadState_WaitSleepJoin);
        
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        ret = SignalObjectAndWait (toSignal, toWait, ms, TRUE);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        
        mono_thread_clr_state (thread, ThreadState_WaitSleepJoin);
 
@@ -2909,9 +2909,9 @@ static void wait_for_tids (struct wait_data *wait, guint32 timeout)
        
        THREAD_DEBUG (g_message("%s: %d threads to wait for in this batch", __func__, wait->num));
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        ret=WaitForMultipleObjectsEx(wait->num, wait->handles, TRUE, timeout, TRUE);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if(ret==WAIT_FAILED) {
                /* See the comment in build_wait_tids() */
@@ -2972,9 +2972,9 @@ static void wait_for_tids_or_state_change (struct wait_data *wait, guint32 timeo
                count++;
        }
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        ret=WaitForMultipleObjectsEx (count, wait->handles, FALSE, timeout, TRUE);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if(ret==WAIT_FAILED) {
                /* See the comment in build_wait_tids() */

diff --git a/mono/mini/debugger-agent.c b/mono/mini/debugger-agent.c
index f20488678275766dead56f79d41d81401b5f4400..e5906b18d89aeee6d1819fd5a1693030d00b9ccd 100644 (file)
--- a/mono/mini/debugger-agent.c
+++ b/mono/mini/debugger-agent.c
@@ -1123,7 +1123,7 @@ socket_transport_recv (void *buf, int len)
        static gint64 last_keepalive;
        gint64 msecs;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        do {
        again:
@@ -1149,7 +1149,7 @@ socket_transport_recv (void *buf, int len)
                }
        } while ((res > 0 && total < len) || (res == -1 && get_last_sock_error () == MONO_EINTR));
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        return total;
 }
@@ -1173,9 +1173,9 @@ set_keepalive (void)
 static int
 socket_transport_accept (int socket_fd)
 {
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        conn_fd = accept (socket_fd, NULL, NULL);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if (conn_fd == -1) {
                fprintf (stderr, "debugger-agent: Unable to listen on %d\n", socket_fd);
@@ -1191,13 +1191,13 @@ socket_transport_send (void *data, int len)
 {
        int res;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        do {
                res = send (conn_fd, data, len, 0);
        } while (res == -1 && get_last_sock_error () == MONO_EINTR);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if (res != len)
                return FALSE;
@@ -1316,9 +1316,9 @@ socket_transport_connect (const char *address)
                        FD_ZERO (&readfds);
                        FD_SET (sfd, &readfds);
 
-                       MONO_PREPARE_BLOCKING;
+                       MONO_ENTER_GC_SAFE;
                        res = select (sfd + 1, &readfds, NULL, NULL, &tv);
-                       MONO_FINISH_BLOCKING;
+                       MONO_EXIT_GC_SAFE;
 
                        if (res == 0) {
                                fprintf (stderr, "debugger-agent: Timed out waiting to connect.\n");
@@ -1345,16 +1345,16 @@ socket_transport_connect (const char *address)
                        if (sfd == -1)
                                continue;
 
-                       MONO_PREPARE_BLOCKING;
+                       MONO_ENTER_GC_SAFE;
                        res = connect (sfd, &sockaddr.addr, sock_len);
-                       MONO_FINISH_BLOCKING;
+                       MONO_EXIT_GC_SAFE;
 
                        if (res != -1)
                                break;       /* Success */
                        
-                       MONO_PREPARE_BLOCKING;
+                       MONO_ENTER_GC_SAFE;
                        close (sfd);
-                       MONO_FINISH_BLOCKING;
+                       MONO_EXIT_GC_SAFE;
                }
 
                if (rp == 0) {
@@ -1385,9 +1385,9 @@ socket_transport_close1 (void)
 #else
        shutdown (conn_fd, SHUT_RD);
        shutdown (listen_fd, SHUT_RDWR);
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        close (listen_fd);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 #endif
 }
 

diff --git a/mono/mini/mini-runtime.c b/mono/mini/mini-runtime.c
index 0e75078f75009e57db7dd6f83ffa24fff4f93e80..ac123365f90fd3e8dd1a0c02f624c89502c41e99 100644 (file)
--- a/mono/mini/mini-runtime.c
+++ b/mono/mini/mini-runtime.c
@@ -956,11 +956,11 @@ mono_jit_thread_attach (MonoDomain *domain, gpointer *dummy)
                        *dummy = NULL;
                        /* mono_thread_attach put the thread in RUNNING mode from STARTING, but we need to
                         * return the right cookie. */
-                       return mono_threads_cookie_for_reset_blocking_start (mono_thread_info_current ());
+                       return mono_threads_enter_gc_unsafe_region_cookie (mono_thread_info_current ());
                } else {
                        *dummy = orig;
                        /* thread state (BLOCKING|RUNNING) -> RUNNING */
-                       return mono_threads_reset_blocking_start (dummy);
+                       return mono_threads_enter_gc_unsafe_region (dummy);
                }
        }
 }
@@ -994,7 +994,7 @@ mono_jit_thread_detach (gpointer cookie, gpointer *dummy)
 
                /* it won't do anything if cookie is NULL
                 * thread state RUNNING -> (RUNNING|BLOCKING) */
-               mono_threads_reset_blocking_end (cookie, dummy);
+               mono_threads_exit_gc_unsafe_region (cookie, dummy);
 
                if (orig != domain) {
                        if (!orig)

diff --git a/mono/mini/mini-trampolines.c b/mono/mini/mini-trampolines.c
index c37e8e106be4d958d1b147d7046f9de3cd1112de..9a71893c239fa4137906d382c43df066c9b1ebde 100644 (file)
--- a/mono/mini/mini-trampolines.c
+++ b/mono/mini/mini-trampolines.c
@@ -814,7 +814,7 @@ mono_magic_trampoline (mgreg_t *regs, guint8 *code, gpointer arg, guint8* tramp)
 {
        gpointer res;
 
-       MONO_PREPARE_RESET_BLOCKING_UNBALANCED;
+       MONO_ENTER_GC_UNSAFE_UNBALANCED;
 
        MonoError error;
 
@@ -825,7 +825,7 @@ mono_magic_trampoline (mgreg_t *regs, guint8 *code, gpointer arg, guint8* tramp)
 
        mono_interruption_checkpoint_from_trampoline ();
 
-       MONO_FINISH_RESET_BLOCKING_UNBALANCED;
+       MONO_EXIT_GC_UNSAFE_UNBALANCED;
 
        return res;
 }

diff --git a/mono/mini/mini.c b/mono/mini/mini.c
index e338816f05ae9d56806d426dcab9aa7b7b1ce245..76adac07895b888867a6e4dd680952b838894803 100644 (file)
--- a/mono/mini/mini.c
+++ b/mono/mini/mini.c
@@ -3133,7 +3133,7 @@ mono_insert_safepoints (MonoCompile *cfg)
 
                if (info && info->subtype == WRAPPER_SUBTYPE_ICALL_WRAPPER &&
                        (info->d.icall.func == mono_thread_interruption_checkpoint ||
-                       info->d.icall.func == mono_threads_finish_blocking_unbalanced)) {
+                       info->d.icall.func == mono_threads_exit_gc_safe_region_unbalanced)) {
                        /* These wrappers are called from the wrapper for the polling function, leading to potential stack overflow */
                        if (cfg->verbose_level > 1)
                                printf ("SKIPPING SAFEPOINTS for wrapper %s\n", cfg->method->name);

diff --git a/mono/utils/mono-coop-mutex.h b/mono/utils/mono-coop-mutex.h
index 0a812754019e814dd9e7be61fbb78edd66a0a3d6..9e074bbea77041bdf92bb715635083023d4947b5 100644 (file)
--- a/mono/utils/mono-coop-mutex.h
+++ b/mono/utils/mono-coop-mutex.h
@@ -50,11 +50,11 @@ mono_coop_mutex_lock (MonoCoopMutex *mutex)
        if (mono_os_mutex_trylock (&mutex->m) == 0)
                return 0;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        res = mono_os_mutex_lock (&mutex->m);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        return res;
 }
@@ -88,11 +88,11 @@ mono_coop_cond_wait (MonoCoopCond *cond, MonoCoopMutex *mutex)
 {
        gint res;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        res = mono_os_cond_wait (&cond->c, &mutex->m);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        return res;
 }
@@ -102,11 +102,11 @@ mono_coop_cond_timedwait (MonoCoopCond *cond, MonoCoopMutex *mutex, guint32 time
 {
        gint res;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        res = mono_os_cond_timedwait (&cond->c, &mutex->m, timeout_ms);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        return res;
 }

diff --git a/mono/utils/mono-coop-semaphore.h b/mono/utils/mono-coop-semaphore.h
index bcf45a2f294d526dcbea6a3abbcffa48d4fdbb9f..3e8a06e8789e46370e212ff6ae13c0d1e730fd5f 100644 (file)
--- a/mono/utils/mono-coop-semaphore.h
+++ b/mono/utils/mono-coop-semaphore.h
@@ -35,11 +35,11 @@ mono_coop_sem_wait (MonoCoopSem *sem, MonoSemFlags flags)
 {
        gint res;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        res = mono_os_sem_wait (&sem->s, flags);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        return res;
 }
@@ -49,11 +49,11 @@ mono_coop_sem_timedwait (MonoCoopSem *sem, guint timeout_ms, MonoSemFlags flags)
 {
        gint res;
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        res = mono_os_sem_timedwait (&sem->s, timeout_ms, flags);
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        return res;
 }

diff --git a/mono/utils/mono-threads-api.h b/mono/utils/mono-threads-api.h
index 42e096efee787b951b4a84fe707de0a9e4fef787..edd71d5eebf82dcb494bbae018c845ae6c09266b 100644 (file)
--- a/mono/utils/mono-threads-api.h
+++ b/mono/utils/mono-threads-api.h
@@ -44,24 +44,23 @@ This will put the current thread in GC Unsafe mode.
 
 For further explanation of what can and can't be done in GC unsafe mode:
 http://www.mono-project.com/docs/advanced/runtime/docs/coop-suspend/#gc-unsafe-mode
-
 */
-#define MONO_BEGIN_GC_UNSAFE   \
+#define MONO_ENTER_GC_UNSAFE   \
        do {    \
-               gpointer __dummy;       \
-               gpointer __gc_unsafe_cookie = mono_threads_enter_gc_unsafe_region (&__dummy)    \
+               gpointer __gc_unsafe_dummy;     \
+               gpointer __gc_unsafe_cookie = mono_threads_enter_gc_unsafe_region (&__gc_unsafe_dummy)  \
 
-#define MONO_END_GC_UNSAFE     \
-               mono_threads_exit_gc_unsafe_region      (__gc_unsafe_cookie, &__dummy); \
+#define MONO_EXIT_GC_UNSAFE    \
+               mono_threads_exit_gc_unsafe_region      (__gc_unsafe_cookie, &__gc_unsafe_dummy);       \
        } while (0)
 
-#define MONO_BEGIN_GC_SAFE     \
+#define MONO_ENTER_GC_SAFE     \
        do {    \
-               gpointer __dummy;       \
-               gpointer __gc_safe_cookie = mono_threads_enter_gc_safe_region (&__dummy)        \
+               gpointer __gc_safe_dummy;       \
+               gpointer __gc_safe_cookie = mono_threads_enter_gc_safe_region (&__gc_safe_dummy)        \
 
-#define MONO_END_GC_SAFE       \
-               mono_threads_exit_gc_safe_region (__gc_safe_cookie, &__dummy);  \
+#define MONO_EXIT_GC_SAFE      \
+               mono_threads_exit_gc_safe_region (__gc_safe_cookie, &__gc_safe_dummy);  \
        } while (0)
 
 MONO_END_DECLS

diff --git a/mono/utils/mono-threads-coop.c b/mono/utils/mono-threads-coop.c
index 31604eab9d7f0358a0f390a185a92f176b843441..a327f581e25457c7b45385a13aae97d14f085669 100644 (file)
--- a/mono/utils/mono-threads-coop.c
+++ b/mono/utils/mono-threads-coop.c
@@ -163,14 +163,14 @@ copy_stack_data (MonoThreadInfo *info, gpointer *stackdata_begin)
 }
 
 gpointer
-mono_threads_prepare_blocking (gpointer *stackdata)
+mono_threads_enter_gc_safe_region (gpointer *stackdata)
 {
        gpointer cookie;
 
        if (!mono_threads_is_coop_enabled ())
                return NULL;
 
-       cookie = mono_threads_prepare_blocking_unbalanced (stackdata);
+       cookie = mono_threads_enter_gc_safe_region_unbalanced (stackdata);
 
 #ifdef ENABLE_CHECKED_BUILD_GC
        if (mono_check_mode_enabled (MONO_CHECK_MODE_GC))
@@ -181,7 +181,7 @@ mono_threads_prepare_blocking (gpointer *stackdata)
 }
 
 gpointer
-mono_threads_prepare_blocking_unbalanced (gpointer *stackdata)
+mono_threads_enter_gc_safe_region_unbalanced (gpointer *stackdata)
 {
        MonoThreadInfo *info;
 
@@ -215,7 +215,7 @@ retry:
 }
 
 void
-mono_threads_finish_blocking (gpointer cookie, gpointer *stackdata)
+mono_threads_exit_gc_safe_region (gpointer cookie, gpointer *stackdata)
 {
        if (!mono_threads_is_coop_enabled ())
                return;
@@ -225,11 +225,11 @@ mono_threads_finish_blocking (gpointer cookie, gpointer *stackdata)
                coop_tls_pop (cookie);
 #endif
 
-       mono_threads_finish_blocking_unbalanced (cookie, stackdata);
+       mono_threads_exit_gc_safe_region_unbalanced (cookie, stackdata);
 }
 
 void
-mono_threads_finish_blocking_unbalanced (gpointer cookie, gpointer *stackdata)
+mono_threads_exit_gc_safe_region_unbalanced (gpointer cookie, gpointer *stackdata)
 {
        static gboolean warned_about_bad_transition;
        MonoThreadInfo *info;
@@ -263,28 +263,21 @@ mono_threads_finish_blocking_unbalanced (gpointer cookie, gpointer *stackdata)
        }
 }
 
-gpointer
-mono_threads_cookie_for_reset_blocking_start (MonoThreadInfo *info)
+void
+mono_threads_assert_gc_safe_region (void)
 {
-       g_assert (mono_threads_is_coop_enabled ());
-
-#ifdef ENABLE_CHECKED_BUILD_GC
-       if (mono_check_mode_enabled (MONO_CHECK_MODE_GC))
-               coop_tls_push (info);
-#endif
-
-       return info;
+       MONO_REQ_GC_SAFE_MODE;
 }
 
 gpointer
-mono_threads_reset_blocking_start (gpointer *stackdata)
+mono_threads_enter_gc_unsafe_region (gpointer *stackdata)
 {
        gpointer cookie;
 
        if (!mono_threads_is_coop_enabled ())
                return NULL;
 
-       cookie = mono_threads_reset_blocking_start_unbalanced (stackdata);
+       cookie = mono_threads_enter_gc_unsafe_region_unbalanced (stackdata);
 
 #ifdef ENABLE_CHECKED_BUILD_GC
        if (mono_check_mode_enabled (MONO_CHECK_MODE_GC))
@@ -295,7 +288,7 @@ mono_threads_reset_blocking_start (gpointer *stackdata)
 }
 
 gpointer
-mono_threads_reset_blocking_start_unbalanced (gpointer *stackdata)
+mono_threads_enter_gc_unsafe_region_unbalanced (gpointer *stackdata)
 {
        MonoThreadInfo *info;
 
@@ -332,8 +325,21 @@ mono_threads_reset_blocking_start_unbalanced (gpointer *stackdata)
        return info;
 }
 
+gpointer
+mono_threads_enter_gc_unsafe_region_cookie (MonoThreadInfo *info)
+{
+       g_assert (mono_threads_is_coop_enabled ());
+
+#ifdef ENABLE_CHECKED_BUILD_GC
+       if (mono_check_mode_enabled (MONO_CHECK_MODE_GC))
+               coop_tls_push (info);
+#endif
+
+       return info;
+}
+
 void
-mono_threads_reset_blocking_end (gpointer cookie, gpointer *stackdata)
+mono_threads_exit_gc_unsafe_region (gpointer cookie, gpointer *stackdata)
 {
        if (!mono_threads_is_coop_enabled ())
                return;
@@ -343,11 +349,11 @@ mono_threads_reset_blocking_end (gpointer cookie, gpointer *stackdata)
                coop_tls_pop (cookie);
 #endif
 
-       mono_threads_reset_blocking_end_unbalanced (cookie, stackdata);
+       mono_threads_exit_gc_unsafe_region_unbalanced (cookie, stackdata);
 }
 
 void
-mono_threads_reset_blocking_end_unbalanced (gpointer cookie, gpointer *stackdata)
+mono_threads_exit_gc_unsafe_region_unbalanced (gpointer cookie, gpointer *stackdata)
 {
        if (!mono_threads_is_coop_enabled ())
                return;
@@ -362,7 +368,13 @@ mono_threads_reset_blocking_end_unbalanced (gpointer cookie, gpointer *stackdata
                g_assert (((MonoThreadInfo *)cookie) == mono_thread_info_current_unchecked ());
        }
 
-       mono_threads_prepare_blocking_unbalanced (stackdata);
+       mono_threads_enter_gc_safe_region_unbalanced (stackdata);
+}
+
+void
+mono_threads_assert_gc_unsafe_region (void)
+{
+       MONO_REQ_GC_UNSAFE_MODE;
 }
 
 void
@@ -396,51 +408,3 @@ mono_threads_coop_end_global_suspend (void)
        if (mono_threads_is_coop_enabled ())
                mono_polling_required = 0;
 }
-
-gpointer
-mono_threads_enter_gc_unsafe_region (gpointer* stackdata)
-{
-       if (!mono_threads_is_coop_enabled ())
-               return NULL;
-
-       return mono_threads_reset_blocking_start (stackdata);
-}
-
-void
-mono_threads_exit_gc_unsafe_region (gpointer cookie, gpointer* stackdata)
-{
-       if (!mono_threads_is_coop_enabled ())
-               return;
-
-       mono_threads_reset_blocking_end (cookie, stackdata);
-}
-
-void
-mono_threads_assert_gc_unsafe_region (void)
-{
-       MONO_REQ_GC_UNSAFE_MODE;
-}
-
-gpointer
-mono_threads_enter_gc_safe_region (gpointer *stackdata)
-{
-       if (!mono_threads_is_coop_enabled ())
-               return NULL;
-
-       return mono_threads_prepare_blocking (stackdata);
-}
-
-void
-mono_threads_exit_gc_safe_region (gpointer cookie, gpointer *stackdata)
-{
-       if (!mono_threads_is_coop_enabled ())
-               return;
-
-       mono_threads_finish_blocking (cookie, stackdata);
-}
-
-void
-mono_threads_assert_gc_safe_region (void)
-{
-       MONO_REQ_GC_SAFE_MODE;
-}

diff --git a/mono/utils/mono-threads-coop.h b/mono/utils/mono-threads-coop.h
index eaf49ee57ffd33ac3f13ac63a280ce9f813ea98b..dae50c19c545fdbedfe86eefef1aaadc48c97b7c 100644 (file)
--- a/mono/utils/mono-threads-coop.h
+++ b/mono/utils/mono-threads-coop.h
@@ -14,6 +14,7 @@
 #include <glib.h>
 
 #include "checked-build.h"
+#include "mono-threads-api.h"
 
 G_BEGIN_DECLS
 
@@ -40,18 +41,6 @@ mono_threads_is_coop_enabled (void)
 void
 mono_threads_state_poll (void);
 
-gpointer
-mono_threads_prepare_blocking (gpointer *stackdata);
-
-void
-mono_threads_finish_blocking (gpointer cookie, gpointer *stackdata);
-
-gpointer
-mono_threads_reset_blocking_start (gpointer *stackdata);
-
-void
-mono_threads_reset_blocking_end (gpointer cookie, gpointer *stackdata);
-
 static inline void
 mono_threads_safepoint (void)
 {
@@ -59,49 +48,30 @@ mono_threads_safepoint (void)
                mono_threads_state_poll ();
 }
 
-#define MONO_PREPARE_BLOCKING  \
-       MONO_REQ_GC_NOT_CRITICAL;               \
-       do {    \
-               gpointer __dummy;       \
-               gpointer __blocking_cookie = mono_threads_prepare_blocking (&__dummy)
-
-#define MONO_FINISH_BLOCKING \
-               mono_threads_finish_blocking (__blocking_cookie, &__dummy);     \
-       } while (0)
-
-#define MONO_PREPARE_RESET_BLOCKING    \
-       do {    \
-               gpointer __dummy;       \
-               gpointer __reset_cookie = mono_threads_reset_blocking_start (&__dummy)
-
-#define MONO_FINISH_RESET_BLOCKING \
-               mono_threads_reset_blocking_end (__reset_cookie, &__dummy);     \
-       } while (0)
-
 /*
  * The following are used for wrappers and trampolines as their
  * calls might be unbalanced, due to exception unwinding.
  */
 
 gpointer
-mono_threads_prepare_blocking_unbalanced (gpointer *stackdata);
+mono_threads_enter_gc_safe_region_unbalanced (gpointer *stackdata);
 
 void
-mono_threads_finish_blocking_unbalanced (gpointer cookie, gpointer *stackdata);
+mono_threads_exit_gc_safe_region_unbalanced (gpointer cookie, gpointer *stackdata);
 
 gpointer
-mono_threads_reset_blocking_start_unbalanced (gpointer *stackdata);
+mono_threads_enter_gc_unsafe_region_unbalanced (gpointer *stackdata);
 
 void
-mono_threads_reset_blocking_end_unbalanced (gpointer cookie, gpointer *stackdata);
+mono_threads_exit_gc_unsafe_region_unbalanced (gpointer cookie, gpointer *stackdata);
 
-#define MONO_PREPARE_RESET_BLOCKING_UNBALANCED \
+#define MONO_ENTER_GC_UNSAFE_UNBALANCED        \
        do {    \
                gpointer __dummy;       \
-               gpointer __reset_cookie = mono_threads_reset_blocking_start_unbalanced (&__dummy)
+               gpointer __reset_cookie = mono_threads_enter_gc_unsafe_region_unbalanced (&__dummy)
 
-#define MONO_FINISH_RESET_BLOCKING_UNBALANCED  \
-               mono_threads_reset_blocking_end_unbalanced (__reset_cookie, &__dummy);  \
+#define MONO_EXIT_GC_UNSAFE_UNBALANCED \
+               mono_threads_exit_gc_unsafe_region_unbalanced (__reset_cookie, &__dummy);       \
        } while (0)
 
 G_END_DECLS

diff --git a/mono/utils/mono-threads.c b/mono/utils/mono-threads.c
index 210ad965dd1000c37a1bb08721879b5cee1cf9d5..1919a00bc965d421efb0042e02ddfc4bd98ffb40 100644 (file)
--- a/mono/utils/mono-threads.c
+++ b/mono/utils/mono-threads.c
@@ -1193,7 +1193,7 @@ mono_thread_info_sleep (guint32 ms, gboolean *alerted)
        if (alerted)
                return sleep_interruptable (ms, alerted);
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
 
        if (ms == INFINITE) {
                do {
@@ -1238,7 +1238,7 @@ mono_thread_info_sleep (guint32 ms, gboolean *alerted)
 #endif /* __linux__ */
        }
 
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        return 0;
 }
@@ -1246,9 +1246,9 @@ mono_thread_info_sleep (guint32 ms, gboolean *alerted)
 gint
 mono_thread_info_usleep (guint64 us)
 {
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        g_usleep (us);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
        return 0;
 }
 

diff --git a/mono/utils/mono-threads.h b/mono/utils/mono-threads.h
index 5641dc746ea3eaa7a1bdecc4cfe82ed01d5a2169..5eea9d0b56e15aa73d6686403acf054868e74522 100644 (file)
--- a/mono/utils/mono-threads.h
+++ b/mono/utils/mono-threads.h
@@ -608,7 +608,7 @@ MonoAbortBlockingResult mono_threads_transition_abort_blocking (THREAD_INFO_TYPE
 MonoThreadUnwindState* mono_thread_info_get_suspend_state (THREAD_INFO_TYPE *info);
 
 gpointer
-mono_threads_cookie_for_reset_blocking_start (THREAD_INFO_TYPE *info);
+mono_threads_enter_gc_unsafe_region_cookie (THREAD_INFO_TYPE *info);
 
 
 void mono_thread_info_wait_for_resume (THREAD_INFO_TYPE *info);

diff --git a/mono/utils/networking-posix.c b/mono/utils/networking-posix.c
index 6a82e68b5a60add404b2d2c00599862fee10d01a..ede69be85f35d83385d2d8acd2e6f5faf3fd44d2 100644 (file)
--- a/mono/utils/networking-posix.c
+++ b/mono/utils/networking-posix.c
@@ -73,9 +73,9 @@ mono_get_address_info (const char *hostname, int port, int flags, MonoAddressInf
 #endif
        sprintf (service_name, "%d", port);
 
-       MONO_PREPARE_BLOCKING;
+       MONO_ENTER_GC_SAFE;
        ret = getaddrinfo (hostname, service_name, &hints, &info);
-       MONO_FINISH_BLOCKING;
+       MONO_EXIT_GC_SAFE;
 
        if (ret)
                return 1; /* FIXME propagate the error */