static void thread_own_mutex (MonoInternalThread *internal, gpointer handle) { mono_w32handle_ref (handle); /* if we are not on the current thread, there is a * race condition when allocating internal->owned_mutexes */ g_assert (mono_thread_internal_is_current (internal)); if (!internal->owned_mutexes) internal->owned_mutexes = g_ptr_array_new (); g_ptr_array_add (internal->owned_mutexes, handle); }
static gboolean search_callback (gpointer handle, gpointer handle_specific, gpointer user_data) { SearchData *search_data = (SearchData*) user_data; if (search_data->type != mono_w32handle_get_type (handle)) return FALSE; if (!search_data->search_user_callback (handle, search_data->search_user_data)) return FALSE; mono_w32handle_ref (handle); search_data->handle = handle; search_data->handle_specific = handle_specific; return TRUE; }
int mono_w32handle_lock_handle (gpointer handle) { MonoW32HandleBase *handle_data; #ifdef DEBUG g_message ("%s: locking handle %p", __func__, handle); #endif if (!mono_w32handle_lookup_data (handle, &handle_data)) { return(0); } mono_w32handle_ref (handle); mono_os_mutex_lock (&handle_data->signal_mutex); return 0; }
static gboolean mono_w32handle_namespace_search_handle_callback (gpointer handle, gpointer data, gpointer user_data) { NamespaceSearchHandleData *search_data; MonoW32HandleType type; MonoW32HandleNamespace *sharedns; type = mono_w32handle_get_type (handle); if (!has_namespace (type)) return FALSE; search_data = (NamespaceSearchHandleData*) user_data; switch (type) { case MONO_W32HANDLE_NAMEDMUTEX: sharedns = mono_w32mutex_get_namespace ((MonoW32HandleNamedMutex*) data); break; case MONO_W32HANDLE_NAMEDSEM: sharedns = mono_w32semaphore_get_namespace ((MonoW32HandleNamedSemaphore*) data); break; case MONO_W32HANDLE_NAMEDEVENT: sharedns = mono_w32event_get_namespace ((MonoW32HandleNamedEvent*) data); break; default: g_assert_not_reached (); } if (strcmp (sharedns->name, search_data->name) == 0) { if (type != search_data->type) { /* Its the wrong type, so fail now */ mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: handle %p matches name but is wrong type: %s", __func__, handle, mono_w32handle_get_typename (type)); search_data->ret = INVALID_HANDLE_VALUE; } else { mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: handle %p matches name and type", __func__, handle); /* we do not want the handle to be destroyed before we return it */ mono_w32handle_ref (handle); search_data->ret = handle; } return TRUE; } return FALSE; }
/** * WaitForMultipleObjectsEx: * @numobjects: The number of objects in @handles. The maximum allowed * is %MAXIMUM_WAIT_OBJECTS. * @handles: An array of object handles. Duplicates are not allowed. * @waitall: If %TRUE, this function waits until all of the handles * are signalled. If %FALSE, this function returns when any object is * signalled. * @timeout: The maximum time in milliseconds to wait for. * @alertable: if TRUE, the wait can be interrupted by an APC call * * This function returns when either one or more of @handles is * signalled, or @timeout ms elapses. If @timeout is zero, the state * of each item of @handles is tested and the function returns * immediately. If @timeout is %INFINITE, the function waits forever. * * Return value: %WAIT_OBJECT_0 to %WAIT_OBJECT_0 + @numobjects - 1 - * if @waitall is %TRUE, indicates that all objects are signalled. If * @waitall is %FALSE, the return value minus %WAIT_OBJECT_0 indicates * the first index into @handles of the objects that are signalled. * %WAIT_ABANDONED_0 to %WAIT_ABANDONED_0 + @numobjects - 1 - if * @waitall is %TRUE, indicates that all objects are signalled, and at * least one object is an abandoned mutex object (See * WaitForSingleObject() for a description of abandoned mutexes.) If * @waitall is %FALSE, the return value minus %WAIT_ABANDONED_0 * indicates the first index into @handles of an abandoned mutex. * %WAIT_TIMEOUT - The @timeout interval elapsed and no objects in * @handles are signalled. %WAIT_FAILED - an error occurred. * %WAIT_IO_COMPLETION - the wait was ended by an APC. */ guint32 WaitForMultipleObjectsEx(guint32 numobjects, gpointer *handles, gboolean waitall, guint32 timeout, gboolean alertable) { gboolean duplicate = FALSE, bogustype = FALSE, done; guint32 count, lowest; guint i; guint32 ret; int thr_ret; gpointer current_thread = wapi_get_current_thread_handle (); guint32 retval; gboolean poll; gpointer sorted_handles [MAXIMUM_WAIT_OBJECTS]; gboolean apc_pending = FALSE; gint64 wait_start, timeout_in_ticks; if (current_thread == NULL) { SetLastError (ERROR_INVALID_HANDLE); return(WAIT_FAILED); } if (numobjects > MAXIMUM_WAIT_OBJECTS) { MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Too many handles: %d", __func__, numobjects); return(WAIT_FAILED); } if (numobjects == 1) { return WaitForSingleObjectEx (handles [0], timeout, alertable); } /* Check for duplicates */ for (i = 0; i < numobjects; i++) { if (handles[i] == _WAPI_THREAD_CURRENT) { handles[i] = wapi_get_current_thread_handle (); if (handles[i] == NULL) { MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Handle %d bogus", __func__, i); bogustype = TRUE; break; } } if ((GPOINTER_TO_UINT (handles[i]) & _WAPI_PROCESS_UNHANDLED) == _WAPI_PROCESS_UNHANDLED) { MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Handle %d pseudo process", __func__, i); bogustype = TRUE; break; } if (mono_w32handle_test_capabilities (handles[i], MONO_W32HANDLE_CAP_WAIT) == FALSE) { MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Handle %p can't be waited for", __func__, handles[i]); bogustype = TRUE; break; } sorted_handles [i] = handles [i]; mono_w32handle_ops_prewait (handles[i]); } qsort (sorted_handles, numobjects, sizeof (gpointer), g_direct_equal); for (i = 1; i < numobjects; i++) { if (sorted_handles [i - 1] == sorted_handles [i]) { duplicate = TRUE; break; } } if (duplicate == TRUE) { MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Returning due to duplicates", __func__); return(WAIT_FAILED); } if (bogustype == TRUE) { MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Returning due to bogus type", __func__); return(WAIT_FAILED); } poll = FALSE; for (i = 0; i < numobjects; ++i) if (mono_w32handle_get_type (handles [i]) == MONO_W32HANDLE_PROCESS) /* Can't wait for a process handle + another handle without polling */ poll = TRUE; done = test_and_own (numobjects, handles, waitall, &count, &lowest); if (done == TRUE) { return(WAIT_OBJECT_0+lowest); } if (timeout == 0) { return WAIT_TIMEOUT; } if (timeout != INFINITE) { wait_start = mono_100ns_ticks (); timeout_in_ticks = (gint64)timeout * 10 * 1000; //can't overflow as timeout is 32bits } /* Have to wait for some or all handles to become signalled */ for (i = 0; i < numobjects; i++) { /* Add a reference, as we need to ensure the handle wont * disappear from under us while we're waiting in the loop * (not lock, as we don't want exclusive access here) */ mono_w32handle_ref (handles[i]); } while(1) { /* Prod all handles with prewait methods and * special-wait handles that aren't already signalled */ for (i = 0; i < numobjects; i++) { mono_w32handle_ops_prewait (handles[i]); if (mono_w32handle_test_capabilities (handles[i], MONO_W32HANDLE_CAP_SPECIAL_WAIT) == TRUE && mono_w32handle_issignalled (handles[i]) == FALSE) { mono_w32handle_ops_specialwait (handles[i], 0, alertable); } } MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: locking signal mutex", __func__); thr_ret = mono_w32handle_lock_signal_mutex (); g_assert (thr_ret == 0); /* Check the signalled state of handles inside the critical section */ if (waitall) { done = TRUE; for (i = 0; i < numobjects; i++) if (!mono_w32handle_issignalled (handles [i])) done = FALSE; } else { done = FALSE; for (i = 0; i < numobjects; i++) if (mono_w32handle_issignalled (handles [i])) done = TRUE; } if (!done) { /* Enter the wait */ if (timeout == INFINITE) { ret = mono_w32handle_timedwait_signal (INFINITE, poll, &apc_pending); } else { gint64 elapsed = mono_100ns_ticks () - wait_start; if (elapsed >= timeout_in_ticks) { ret = WAIT_TIMEOUT; } else { ret = mono_w32handle_timedwait_signal ((timeout_in_ticks - elapsed) / 10 / 1000, poll, &apc_pending); } } } else { /* No need to wait */ ret = 0; } MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: unlocking signal mutex", __func__); thr_ret = mono_w32handle_unlock_signal_mutex (); g_assert (thr_ret == 0); if (alertable && apc_pending) { retval = WAIT_IO_COMPLETION; break; } /* Check if everything is signalled, as we can't * guarantee to notice a shared signal even if the * wait timed out */ done = test_and_own (numobjects, handles, waitall, &count, &lowest); if (done == TRUE) { retval = WAIT_OBJECT_0+lowest; break; } else if (ret != 0) { /* Didn't get all handles, and there was a * timeout or other error */ MONO_TRACE (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: wait returned error: %s", __func__, strerror (ret)); if(ret==ETIMEDOUT) { retval = WAIT_TIMEOUT; } else { retval = WAIT_FAILED; } break; } } for (i = 0; i < numobjects; i++) { /* Unref everything we reffed above */ mono_w32handle_unref (handles[i]); } return retval; }