[w32handle] Rename `statuscode` parameter to `abandoned`

This parameter is only used to check if a mutex has been abandonned.

diff --git a/mono/metadata/w32event-unix.c b/mono/metadata/w32event-unix.c
index 6c95aaf56c9e97a4f48828e29a602be528d04970..af5b890d16279cc8bbc2d4ea525d55db84b6a4fe 100644 (file)
--- a/mono/metadata/w32event-unix.c
+++ b/mono/metadata/w32event-unix.c
@@ -24,12 +24,12 @@ struct MonoW32HandleNamedEvent {
        MonoW32HandleNamespace sharedns;
 };
 
-static gboolean event_handle_own (gpointer handle, MonoW32HandleType type, guint32 *statuscode)
+static gboolean event_handle_own (gpointer handle, MonoW32HandleType type, gboolean *abandoned)
 {
        MonoW32HandleEvent *event_handle;
        gboolean ok;
 
-       *statuscode = WAIT_OBJECT_0;
+       *abandoned = FALSE;
 
        ok = mono_w32handle_lookup (handle, type, (gpointer *)&event_handle);
        if (!ok) {
@@ -57,9 +57,9 @@ static void event_signal(gpointer handle)
        ves_icall_System_Threading_Events_SetEvent_internal (handle);
 }
 
-static gboolean event_own (gpointer handle, guint32 *statuscode)
+static gboolean event_own (gpointer handle, gboolean *abandoned)
 {
-       return event_handle_own (handle, MONO_W32HANDLE_EVENT, statuscode);
+       return event_handle_own (handle, MONO_W32HANDLE_EVENT, abandoned);
 }
 
 static void namedevent_signal (gpointer handle)
@@ -68,9 +68,9 @@ static void namedevent_signal (gpointer handle)
 }
 
 /* NB, always called with the shared handle lock held */
-static gboolean namedevent_own (gpointer handle, guint32 *statuscode)
+static gboolean namedevent_own (gpointer handle, gboolean *abandoned)
 {
-       return event_handle_own (handle, MONO_W32HANDLE_NAMEDEVENT, statuscode);
+       return event_handle_own (handle, MONO_W32HANDLE_NAMEDEVENT, abandoned);
 }
 
 static void event_details (gpointer data)

diff --git a/mono/metadata/w32handle.c b/mono/metadata/w32handle.c
index 88895e7fb5e3624bdd1db59faaf69f1a3895f2ab..0336911e0d1799684379924806be8f57284be03f 100644 (file)
--- a/mono/metadata/w32handle.c
+++ b/mono/metadata/w32handle.c
@@ -771,7 +771,7 @@ mono_w32handle_ops_signal (gpointer handle)
 }
 
 static gboolean
-mono_w32handle_ops_own (gpointer handle, guint32 *statuscode)
+mono_w32handle_ops_own (gpointer handle, gboolean *abandoned)
 {
        MonoW32HandleBase *handle_data;
        MonoW32HandleType type;
@@ -783,7 +783,7 @@ mono_w32handle_ops_own (gpointer handle, guint32 *statuscode)
        type = handle_data->type;
 
        if (handle_ops[type] != NULL && handle_ops[type]->own_handle != NULL) {
-               return(handle_ops[type]->own_handle (handle, statuscode));
+               return(handle_ops[type]->own_handle (handle, abandoned));
        } else {
                return(FALSE);
        }
@@ -1078,24 +1078,24 @@ void mono_w32handle_dump (void)
 }
 
 static gboolean
-own_if_signalled (gpointer handle, guint32 *statuscode)
+own_if_signalled (gpointer handle, gboolean *abandoned)
 {
        if (!mono_w32handle_issignalled (handle))
                return FALSE;
 
-       *statuscode = WAIT_OBJECT_0;
-       mono_w32handle_ops_own (handle, statuscode);
+       *abandoned = FALSE;
+       mono_w32handle_ops_own (handle, abandoned);
        return TRUE;
 }
 
 static gboolean
-own_if_owned( gpointer handle, guint32 *statuscode)
+own_if_owned( gpointer handle, gboolean *abandoned)
 {
        if (!mono_w32handle_ops_isowned (handle))
                return FALSE;
 
-       *statuscode = WAIT_OBJECT_0;
-       mono_w32handle_ops_own (handle, statuscode);
+       *abandoned = FALSE;
+       mono_w32handle_ops_own (handle, abandoned);
        return TRUE;
 }
 
@@ -1105,7 +1105,7 @@ mono_w32handle_wait_one (gpointer handle, guint32 timeout, gboolean alertable)
        MonoW32HandleWaitRet ret;
        gboolean alerted;
        gint64 start;
-       guint32 statuscode = 0;
+       gboolean abandoned = FALSE;
 
        alerted = FALSE;
 
@@ -1126,11 +1126,11 @@ mono_w32handle_wait_one (gpointer handle, guint32 timeout, gboolean alertable)
        mono_w32handle_lock_handle (handle);
 
        if (mono_w32handle_test_capabilities (handle, MONO_W32HANDLE_CAP_OWN)) {
-               if (own_if_owned (handle, &statuscode)) {
+               if (own_if_owned (handle, &abandoned)) {
                        mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_W32HANDLE, "%s: handle %p already owned",
                                __func__, handle);
 
-                       ret = statuscode == WAIT_ABANDONED_0 ? MONO_W32HANDLE_WAIT_RET_ABANDONED_0 : MONO_W32HANDLE_WAIT_RET_SUCCESS_0;
+                       ret = abandoned ? MONO_W32HANDLE_WAIT_RET_ABANDONED_0 : MONO_W32HANDLE_WAIT_RET_SUCCESS_0;
                        goto done;
                }
        }
@@ -1141,11 +1141,11 @@ mono_w32handle_wait_one (gpointer handle, guint32 timeout, gboolean alertable)
        for (;;) {
                gint waited;
 
-               if (own_if_signalled (handle, &statuscode)) {
+               if (own_if_signalled (handle, &abandoned)) {
                        mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_W32HANDLE, "%s: handle %p signalled",
                                __func__, handle);
 
-                       ret = statuscode == WAIT_ABANDONED_0 ? MONO_W32HANDLE_WAIT_RET_ABANDONED_0 : MONO_W32HANDLE_WAIT_RET_SUCCESS_0;
+                       ret = abandoned ? MONO_W32HANDLE_WAIT_RET_ABANDONED_0 : MONO_W32HANDLE_WAIT_RET_SUCCESS_0;
                        goto done;
                }
 
@@ -1190,7 +1190,7 @@ mono_w32handle_wait_multiple (gpointer *handles, gsize nhandles, gboolean waital
        gint i;
        gint64 start;
        gpointer handles_sorted [MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS];
-       guint32 statuscodes [MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS] = {0};
+       gboolean abandoned [MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS] = {0};
 
        if (nhandles == 0)
                return MONO_W32HANDLE_WAIT_RET_FAILED;
@@ -1273,7 +1273,7 @@ mono_w32handle_wait_multiple (gpointer *handles, gsize nhandles, gboolean waital
 
                if (signalled) {
                        for (i = 0; i < nhandles; i++)
-                               own_if_signalled (handles [i], &statuscodes [i]);
+                               own_if_signalled (handles [i], &abandoned [i]);
                }
 
                mono_w32handle_unlock_handles (handles, nhandles);
@@ -1281,7 +1281,7 @@ mono_w32handle_wait_multiple (gpointer *handles, gsize nhandles, gboolean waital
                if (signalled) {
                        ret = MONO_W32HANDLE_WAIT_RET_SUCCESS_0 + lowest;
                        for (i = lowest; i < nhandles; i++) {
-                               if (statuscodes [i] == WAIT_ABANDONED_0) {
+                               if (abandoned [i]) {
                                        ret = MONO_W32HANDLE_WAIT_RET_ABANDONED_0 + lowest;
                                        break;
                                }
@@ -1368,7 +1368,7 @@ mono_w32handle_signal_and_wait (gpointer signal_handle, gpointer wait_handle, gu
        MonoW32HandleWaitRet ret;
        gint64 start;
        gboolean alerted;
-       guint32 statuscode = 0;
+       gboolean abandoned = FALSE;
        gpointer handles [2];
 
        alerted = FALSE;
@@ -1393,11 +1393,11 @@ mono_w32handle_signal_and_wait (gpointer signal_handle, gpointer wait_handle, gu
        mono_w32handle_unlock_handle (signal_handle);
 
        if (mono_w32handle_test_capabilities (wait_handle, MONO_W32HANDLE_CAP_OWN)) {
-               if (own_if_owned (wait_handle, &statuscode)) {
+               if (own_if_owned (wait_handle, &abandoned)) {
                        mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_W32HANDLE, "%s: handle %p already owned",
                                __func__, wait_handle);
 
-                       ret = statuscode == WAIT_ABANDONED_0 ? MONO_W32HANDLE_WAIT_RET_ABANDONED_0 : MONO_W32HANDLE_WAIT_RET_SUCCESS_0;
+                       ret = abandoned ? MONO_W32HANDLE_WAIT_RET_ABANDONED_0 : MONO_W32HANDLE_WAIT_RET_SUCCESS_0;
                        goto done;
                }
        }
@@ -1408,11 +1408,11 @@ mono_w32handle_signal_and_wait (gpointer signal_handle, gpointer wait_handle, gu
        for (;;) {
                gint waited;
 
-               if (own_if_signalled (wait_handle, &statuscode)) {
+               if (own_if_signalled (wait_handle, &abandoned)) {
                        mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_W32HANDLE, "%s: handle %p signalled",
                                __func__, wait_handle);
 
-                       ret = statuscode == WAIT_ABANDONED_0 ? MONO_W32HANDLE_WAIT_RET_ABANDONED_0 : MONO_W32HANDLE_WAIT_RET_SUCCESS_0;
+                       ret = abandoned ? MONO_W32HANDLE_WAIT_RET_ABANDONED_0 : MONO_W32HANDLE_WAIT_RET_SUCCESS_0;
                        goto done;
                }
 

diff --git a/mono/metadata/w32handle.h b/mono/metadata/w32handle.h
index 801e32a3cc87d34553b4022b15961dad6eb87148..db536d40805d17767439c3e886a92d14adb80ef4 100644 (file)
--- a/mono/metadata/w32handle.h
+++ b/mono/metadata/w32handle.h
@@ -55,10 +55,10 @@ typedef struct
        /* Called by mono_w32handle_wait_one and mono_w32handle_wait_multiple,
         * with the handle locked (shared handles aren't locked.)
         * Returns TRUE if ownership was established, false otherwise.
-        * If TRUE, *statuscode contains a status code such as
+        * If TRUE, *abandoned contains a status code such as
         * WAIT_OBJECT_0 or WAIT_ABANDONED_0.
         */
-       gboolean (*own_handle)(gpointer handle, guint32 *statuscode);
+       gboolean (*own_handle)(gpointer handle, gboolean *abandoned);
 
        /* Called by mono_w32handle_wait_one and mono_w32handle_wait_multiple, if the
         * handle in question is "ownable" (ie mutexes), to see if the current

diff --git a/mono/metadata/w32mutex-unix.c b/mono/metadata/w32mutex-unix.c
index d27fd5b8a586dbb182643b647e97dcafadd97d95..a39f5ca276163804a73af82022d485a634a10562 100644 (file)
--- a/mono/metadata/w32mutex-unix.c
+++ b/mono/metadata/w32mutex-unix.c
@@ -59,11 +59,11 @@ thread_disown_mutex (MonoInternalThread *internal, gpointer handle)
 }
 
 static gboolean
-mutex_handle_own (gpointer handle, MonoW32HandleType type, guint32 *statuscode)
+mutex_handle_own (gpointer handle, MonoW32HandleType type, gboolean *abandoned)
 {
        MonoW32HandleMutex *mutex_handle;
 
-       *statuscode = WAIT_OBJECT_0;
+       *abandoned = FALSE;
 
        if (!mono_w32handle_lookup (handle, type, (gpointer *)&mutex_handle)) {
                g_warning ("%s: error looking up %s handle %p", __func__, mono_w32handle_get_typename (type), handle);
@@ -85,7 +85,7 @@ mutex_handle_own (gpointer handle, MonoW32HandleType type, guint32 *statuscode)
 
        if (mutex_handle->abandoned) {
                mutex_handle->abandoned = FALSE;
-               *statuscode = WAIT_ABANDONED_0;
+               *abandoned = TRUE;
        }
 
        mono_w32handle_set_signal_state (handle, FALSE, FALSE);
@@ -122,9 +122,9 @@ static void mutex_signal(gpointer handle)
        ves_icall_System_Threading_Mutex_ReleaseMutex_internal (handle);
 }
 
-static gboolean mutex_own (gpointer handle, guint32 *statuscode)
+static gboolean mutex_own (gpointer handle, gboolean *abandoned)
 {
-       return mutex_handle_own (handle, MONO_W32HANDLE_MUTEX, statuscode);
+       return mutex_handle_own (handle, MONO_W32HANDLE_MUTEX, abandoned);
 }
 
 static gboolean mutex_is_owned (gpointer handle)
@@ -139,9 +139,9 @@ static void namedmutex_signal (gpointer handle)
 }
 
 /* NB, always called with the shared handle lock held */
-static gboolean namedmutex_own (gpointer handle, guint32 *statuscode)
+static gboolean namedmutex_own (gpointer handle, gboolean *abandoned)
 {
-       return mutex_handle_own (handle, MONO_W32HANDLE_NAMEDMUTEX, statuscode);
+       return mutex_handle_own (handle, MONO_W32HANDLE_NAMEDMUTEX, abandoned);
 }
 
 static gboolean namedmutex_is_owned (gpointer handle)
@@ -264,7 +264,7 @@ mono_w32mutex_init (void)
 static gpointer mutex_handle_create (MonoW32HandleMutex *mutex_handle, MonoW32HandleType type, gboolean owned)
 {
        gpointer handle;
-       guint32 statuscode;
+       gboolean abandoned;
 
        mutex_handle->tid = 0;
        mutex_handle->recursion = 0;
@@ -281,7 +281,7 @@ static gpointer mutex_handle_create (MonoW32HandleMutex *mutex_handle, MonoW32Ha
        mono_w32handle_lock_handle (handle);
 
        if (owned)
-               mutex_handle_own (handle, type, &statuscode);
+               mutex_handle_own (handle, type, &abandoned);
        else
                mono_w32handle_set_signal_state (handle, TRUE, FALSE);
 

diff --git a/mono/metadata/w32semaphore-unix.c b/mono/metadata/w32semaphore-unix.c
index f0a93d1f985384045bcff34f5d44debd2d2d3270..bcecd8cb558381ea08df99bb5e3bc3e0ba8b5528 100644 (file)
--- a/mono/metadata/w32semaphore-unix.c
+++ b/mono/metadata/w32semaphore-unix.c
@@ -24,11 +24,11 @@ struct MonoW32HandleNamedSemaphore {
        MonoW32HandleNamespace sharedns;
 };
 
-static gboolean sem_handle_own (gpointer handle, MonoW32HandleType type, guint32 *statuscode)
+static gboolean sem_handle_own (gpointer handle, MonoW32HandleType type, gboolean *abandoned)
 {
        MonoW32HandleSemaphore *sem_handle;
 
-       *statuscode = WAIT_OBJECT_0;
+       *abandoned = FALSE;
 
        if (!mono_w32handle_lookup (handle, type, (gpointer *)&sem_handle)) {
                g_warning ("%s: error looking up %s handle %p",
@@ -52,9 +52,9 @@ static void sema_signal(gpointer handle)
        ves_icall_System_Threading_Semaphore_ReleaseSemaphore_internal(handle, 1, NULL);
 }
 
-static gboolean sema_own (gpointer handle, guint32 *statuscode)
+static gboolean sema_own (gpointer handle, gboolean *abandoned)
 {
-       return sem_handle_own (handle, MONO_W32HANDLE_SEM, statuscode);
+       return sem_handle_own (handle, MONO_W32HANDLE_SEM, abandoned);
 }
 
 static void namedsema_signal (gpointer handle)
@@ -63,9 +63,9 @@ static void namedsema_signal (gpointer handle)
 }
 
 /* NB, always called with the shared handle lock held */
-static gboolean namedsema_own (gpointer handle, guint32 *statuscode)
+static gboolean namedsema_own (gpointer handle, gboolean *abandoned)
 {
-       return sem_handle_own (handle, MONO_W32HANDLE_NAMEDSEM, statuscode);
+       return sem_handle_own (handle, MONO_W32HANDLE_NAMEDSEM, abandoned);
 }
 
 static void sema_details (gpointer data)