2 * mutexes.c: Mutex handles
5 * Dick Porter (dick@ximian.com)
7 * (C) 2002-2006 Ximian, Inc.
16 #include <mono/io-layer/wapi.h>
17 #include <mono/io-layer/wapi-private.h>
18 #include <mono/io-layer/misc-private.h>
19 #include <mono/io-layer/handles-private.h>
20 #include <mono/io-layer/mono-mutex.h>
21 #include <mono/io-layer/mutex-private.h>
25 static void mutex_signal(gpointer handle);
26 static gboolean mutex_own (gpointer handle);
27 static gboolean mutex_is_owned (gpointer handle);
29 static void namedmutex_signal (gpointer handle);
30 static gboolean namedmutex_own (gpointer handle);
31 static gboolean namedmutex_is_owned (gpointer handle);
32 static void namedmutex_prewait (gpointer handle);
34 struct _WapiHandleOps _wapi_mutex_ops = {
36 mutex_signal, /* signal */
38 mutex_is_owned, /* is_owned */
39 NULL, /* special_wait */
43 void _wapi_mutex_details (gpointer handle_info)
45 struct _WapiHandle_mutex *mut = (struct _WapiHandle_mutex *)handle_info;
47 #ifdef PTHREAD_POINTER_ID
48 g_print ("own: %5d:%5p, count: %5u", mut->pid, mut->tid,
51 g_print ("own: %5d:%5ld, count: %5u", mut->pid, mut->tid,
56 struct _WapiHandleOps _wapi_namedmutex_ops = {
58 namedmutex_signal, /* signal */
59 namedmutex_own, /* own */
60 namedmutex_is_owned, /* is_owned */
61 NULL, /* special_wait */
62 namedmutex_prewait /* prewait */
65 static gboolean mutex_release (gpointer handle);
66 static gboolean namedmutex_release (gpointer handle);
70 gboolean (*release)(gpointer handle);
71 } mutex_ops[WAPI_HANDLE_COUNT] = {
86 static mono_once_t mutex_ops_once=MONO_ONCE_INIT;
88 static void mutex_ops_init (void)
90 _wapi_handle_register_capabilities (WAPI_HANDLE_MUTEX,
91 WAPI_HANDLE_CAP_WAIT |
92 WAPI_HANDLE_CAP_SIGNAL |
94 _wapi_handle_register_capabilities (WAPI_HANDLE_NAMEDMUTEX,
95 WAPI_HANDLE_CAP_WAIT |
96 WAPI_HANDLE_CAP_SIGNAL |
100 static void mutex_signal(gpointer handle)
102 ReleaseMutex(handle);
105 static gboolean mutex_own (gpointer handle)
107 struct _WapiHandle_mutex *mutex_handle;
110 ok = _wapi_lookup_handle (handle, WAPI_HANDLE_MUTEX,
111 (gpointer *)&mutex_handle);
113 g_warning ("%s: error looking up mutex handle %p", __func__,
118 _wapi_thread_own_mutex (handle);
121 g_message("%s: owning mutex handle %p", __func__, handle);
124 _wapi_handle_set_signal_state (handle, FALSE, FALSE);
126 mutex_handle->pid = _wapi_getpid ();
127 mutex_handle->tid = pthread_self ();
128 mutex_handle->recursion++;
131 g_message ("%s: mutex handle %p locked %d times by %d:%ld", __func__,
132 handle, mutex_handle->recursion, mutex_handle->pid,
139 static gboolean mutex_is_owned (gpointer handle)
141 struct _WapiHandle_mutex *mutex_handle;
144 ok=_wapi_lookup_handle (handle, WAPI_HANDLE_MUTEX,
145 (gpointer *)&mutex_handle);
147 g_warning ("%s: error looking up mutex handle %p", __func__,
153 g_message("%s: testing ownership mutex handle %p", __func__, handle);
156 if (mutex_handle->recursion > 0 &&
157 mutex_handle->pid == _wapi_getpid () &&
158 pthread_equal (mutex_handle->tid, pthread_self ())) {
160 g_message ("%s: mutex handle %p owned by %d:%ld", __func__,
161 handle, _wapi_getpid (), pthread_self ());
167 g_message ("%s: mutex handle %p not owned by %d:%ld, but locked %d times by %d:%ld", __func__, handle, _wapi_getpid (), pthread_self (), mutex_handle->recursion, mutex_handle->pid, mutex_handle->tid);
174 static void namedmutex_signal (gpointer handle)
176 ReleaseMutex(handle);
179 /* NB, always called with the shared handle lock held */
180 static gboolean namedmutex_own (gpointer handle)
182 struct _WapiHandle_namedmutex *namedmutex_handle;
186 g_message ("%s: owning named mutex handle %p", __func__, handle);
189 ok = _wapi_lookup_handle (handle, WAPI_HANDLE_NAMEDMUTEX,
190 (gpointer *)&namedmutex_handle);
192 g_warning ("%s: error looking up named mutex handle %p",
197 _wapi_thread_own_mutex (handle);
199 namedmutex_handle->pid = _wapi_getpid ();
200 namedmutex_handle->tid = pthread_self ();
201 namedmutex_handle->recursion++;
203 _wapi_shared_handle_set_signal_state (handle, FALSE);
206 g_message ("%s: mutex handle %p locked %d times by %d:%ld", __func__,
207 handle, namedmutex_handle->recursion,
208 namedmutex_handle->pid, namedmutex_handle->tid);
214 static gboolean namedmutex_is_owned (gpointer handle)
216 struct _WapiHandle_namedmutex *namedmutex_handle;
219 ok = _wapi_lookup_handle (handle, WAPI_HANDLE_NAMEDMUTEX,
220 (gpointer *)&namedmutex_handle);
222 g_warning ("%s: error looking up mutex handle %p", __func__,
228 g_message ("%s: testing ownership mutex handle %p", __func__, handle);
231 if (namedmutex_handle->recursion > 0 &&
232 namedmutex_handle->pid == _wapi_getpid () &&
233 pthread_equal (namedmutex_handle->tid, pthread_self ())) {
235 g_message ("%s: mutex handle %p owned by %d:%ld", __func__,
236 handle, _wapi_getpid (), pthread_self ());
242 g_message ("%s: mutex handle %p not owned by %d:%ld, but locked %d times by %d:%ld", __func__, handle, _wapi_getpid (), pthread_self (), namedmutex_handle->recursion, namedmutex_handle->pid, namedmutex_handle->tid);
249 /* The shared state is not locked when prewait methods are called */
250 static void namedmutex_prewait (gpointer handle)
252 /* If the mutex is not currently owned, do nothing and let the
253 * usual wait carry on. If it is owned, check that the owner
254 * is still alive; if it isn't we override the previous owner
255 * and assume that process exited abnormally and failed to
258 struct _WapiHandle_namedmutex *namedmutex_handle;
261 ok = _wapi_lookup_handle (handle, WAPI_HANDLE_NAMEDMUTEX,
262 (gpointer *)&namedmutex_handle);
264 g_warning ("%s: error looking up named mutex handle %p",
270 g_message ("%s: Checking ownership of named mutex handle %p", __func__,
274 if (namedmutex_handle->recursion == 0) {
276 g_message ("%s: Named mutex handle %p not owned", __func__,
279 } else if (namedmutex_handle->pid == _wapi_getpid ()) {
281 g_message ("%s: Named mutex handle %p owned by this process",
285 guint32 *pids = g_new0 (guint32, 32);
286 guint32 count = 32, needed_bytes, i;
291 g_message ("%s: Named mutex handle %p owned by another process", __func__, handle);
294 ret = EnumProcesses (pids, count * sizeof(guint32),
298 count = needed_bytes / sizeof(guint32);
300 g_message ("%s: Retrying pid lookup with %d slots", __func__, count);
302 pids = g_renew (guint32, pids, count);
303 ret = EnumProcesses (pids, needed_bytes,
305 } while (ret == FALSE);
308 count = needed_bytes / sizeof(guint32);
311 g_message ("%s: Need to look at %d pids for named mutex handle %p", __func__, count, handle);
314 thr_ret = _wapi_handle_lock_shared_handles ();
315 g_assert (thr_ret == 0);
317 for (i = 0; i < count; i++) {
319 g_message ("%s: Checking pid %d for named mutex handle %p", __func__, pids[i], handle);
322 if (pids[i] == namedmutex_handle->pid) {
323 /* Must be still alive, because
324 * EnumProcesses() checks for us
327 g_message ("%s: Found active pid %d for named mutex handle %p", __func__, pids[i], handle);
337 /* Didn't find the process that this handle
338 * was owned by, overriding it
342 g_message ("%s: overriding old owner of named mutex handle %p", __func__, handle);
345 namedmutex_handle->pid = 0;
346 namedmutex_handle->tid = 0;
347 namedmutex_handle->recursion = 0;
349 _wapi_shared_handle_set_signal_state (handle, TRUE);
352 _wapi_handle_unlock_shared_handles ();
356 static void mutex_abandon (gpointer handle, pid_t pid, pthread_t tid)
358 struct _WapiHandle_mutex *mutex_handle;
362 ok = _wapi_lookup_handle (handle, WAPI_HANDLE_MUTEX,
363 (gpointer *)&mutex_handle);
365 g_warning ("%s: error looking up mutex handle %p", __func__,
370 pthread_cleanup_push ((void(*)(void *))_wapi_handle_unlock_handle,
372 thr_ret = _wapi_handle_lock_handle (handle);
373 g_assert (thr_ret == 0);
375 if (mutex_handle->pid == pid &&
376 pthread_equal (mutex_handle->tid, tid)) {
378 g_message ("%s: Mutex handle %p abandoned!", __func__, handle);
381 mutex_handle->recursion = 0;
382 mutex_handle->pid = 0;
383 mutex_handle->tid = 0;
385 _wapi_handle_set_signal_state (handle, TRUE, FALSE);
388 thr_ret = _wapi_handle_unlock_handle (handle);
389 g_assert (thr_ret == 0);
390 pthread_cleanup_pop (0);
393 static void namedmutex_abandon (gpointer handle, pid_t pid, pthread_t tid)
395 struct _WapiHandle_namedmutex *mutex_handle;
399 ok = _wapi_lookup_handle (handle, WAPI_HANDLE_NAMEDMUTEX,
400 (gpointer *)&mutex_handle);
402 g_warning ("%s: error looking up named mutex handle %p",
407 thr_ret = _wapi_handle_lock_shared_handles ();
408 g_assert (thr_ret == 0);
410 if (mutex_handle->pid == pid &&
411 pthread_equal (mutex_handle->tid, tid)) {
413 g_message ("%s: Mutex handle %p abandoned!", __func__, handle);
416 mutex_handle->recursion = 0;
417 mutex_handle->pid = 0;
418 mutex_handle->tid = 0;
420 _wapi_shared_handle_set_signal_state (handle, TRUE);
423 _wapi_handle_unlock_shared_handles ();
426 /* When a thread exits, any mutexes it still holds need to be
427 * signalled. This function must not be called with the shared handle
428 * lock held, as namedmutex_abandon () will try to acquire it
430 void _wapi_mutex_abandon (gpointer data, pid_t pid, pthread_t tid)
432 WapiHandleType type = _wapi_handle_type (data);
434 if (type == WAPI_HANDLE_MUTEX) {
435 mutex_abandon (data, pid, tid);
436 } else if (type == WAPI_HANDLE_NAMEDMUTEX) {
437 namedmutex_abandon (data, pid, tid);
439 g_assert_not_reached ();
443 static gpointer mutex_create (WapiSecurityAttributes *security G_GNUC_UNUSED,
446 struct _WapiHandle_mutex mutex_handle = {0};
450 /* Need to blow away any old errors here, because code tests
451 * for ERROR_ALREADY_EXISTS on success (!) to see if a mutex
452 * was freshly created
454 SetLastError (ERROR_SUCCESS);
457 g_message ("%s: Creating unnamed mutex", __func__);
460 handle = _wapi_handle_new (WAPI_HANDLE_MUTEX, &mutex_handle);
461 if (handle == _WAPI_HANDLE_INVALID) {
462 g_warning ("%s: error creating mutex handle", __func__);
463 SetLastError (ERROR_GEN_FAILURE);
467 pthread_cleanup_push ((void(*)(void *))_wapi_handle_unlock_handle,
469 thr_ret = _wapi_handle_lock_handle (handle);
470 g_assert (thr_ret == 0);
475 _wapi_handle_set_signal_state (handle, TRUE, FALSE);
479 g_message ("%s: returning mutex handle %p", __func__, handle);
482 thr_ret = _wapi_handle_unlock_handle (handle);
483 g_assert (thr_ret == 0);
484 pthread_cleanup_pop (0);
489 static gpointer namedmutex_create (WapiSecurityAttributes *security G_GNUC_UNUSED, gboolean owned,
490 const gunichar2 *name)
492 struct _WapiHandle_namedmutex namedmutex_handle = {{{0}}, 0};
500 /* w32 seems to guarantee that opening named objects can't
503 thr_ret = _wapi_namespace_lock ();
504 g_assert (thr_ret == 0);
506 /* Need to blow away any old errors here, because code tests
507 * for ERROR_ALREADY_EXISTS on success (!) to see if a mutex
508 * was freshly created
510 SetLastError (ERROR_SUCCESS);
512 utf8_name = g_utf16_to_utf8 (name, -1, NULL, NULL, NULL);
515 g_message ("%s: Creating named mutex [%s]", __func__, utf8_name);
518 offset = _wapi_search_handle_namespace (WAPI_HANDLE_NAMEDMUTEX,
521 /* The name has already been used for a different
524 SetLastError (ERROR_INVALID_HANDLE);
526 } else if (offset != 0) {
527 /* Not an error, but this is how the caller is
528 * informed that the mutex wasn't freshly created
530 SetLastError (ERROR_ALREADY_EXISTS);
532 /* Fall through to create the mutex handle. */
535 /* A new named mutex, so create both the private and
539 if (strlen (utf8_name) < MAX_PATH) {
540 namelen = strlen (utf8_name);
545 memcpy (&namedmutex_handle.sharedns.name, utf8_name, namelen);
547 handle = _wapi_handle_new (WAPI_HANDLE_NAMEDMUTEX,
550 /* A new reference to an existing named mutex, so just
551 * create the private part
553 handle = _wapi_handle_new_from_offset (WAPI_HANDLE_NAMEDMUTEX,
557 if (handle == _WAPI_HANDLE_INVALID) {
558 g_warning ("%s: error creating mutex handle", __func__);
559 SetLastError (ERROR_GEN_FAILURE);
565 /* Set the initial state, as this is a completely new
568 thr_ret = _wapi_handle_lock_shared_handles ();
569 g_assert (thr_ret == 0);
572 namedmutex_own (handle);
574 _wapi_shared_handle_set_signal_state (handle, TRUE);
577 _wapi_handle_unlock_shared_handles ();
581 g_message ("%s: returning mutex handle %p", __func__, handle);
587 _wapi_namespace_unlock (NULL);
594 * @security: Ignored for now.
595 * @owned: If %TRUE, the mutex is created with the calling thread
596 * already owning the mutex.
597 * @name:Pointer to a string specifying the name of this mutex, or
600 * Creates a new mutex handle. A mutex is signalled when no thread
601 * owns it. A thread acquires ownership of the mutex by waiting for
602 * it with WaitForSingleObject() or WaitForMultipleObjects(). A
603 * thread relinquishes ownership with ReleaseMutex().
605 * A thread that owns a mutex can specify the same mutex in repeated
606 * wait function calls without blocking. The thread must call
607 * ReleaseMutex() an equal number of times to release the mutex.
609 * Return value: A new handle, or %NULL on error.
611 gpointer CreateMutex(WapiSecurityAttributes *security G_GNUC_UNUSED, gboolean owned,
612 const gunichar2 *name)
614 mono_once (&mutex_ops_once, mutex_ops_init);
617 return(mutex_create (security, owned));
619 return(namedmutex_create (security, owned, name));
623 static gboolean mutex_release (gpointer handle)
625 struct _WapiHandle_mutex *mutex_handle;
627 pthread_t tid = pthread_self ();
628 pid_t pid = _wapi_getpid ();
630 gboolean ret = FALSE;
632 ok = _wapi_lookup_handle (handle, WAPI_HANDLE_MUTEX,
633 (gpointer *)&mutex_handle);
635 g_warning ("%s: error looking up mutex handle %p", __func__,
640 pthread_cleanup_push ((void(*)(void *))_wapi_handle_unlock_handle,
642 thr_ret = _wapi_handle_lock_handle (handle);
643 g_assert (thr_ret == 0);
646 g_message("%s: Releasing mutex handle %p", __func__, handle);
649 if (!pthread_equal (mutex_handle->tid, tid) ||
650 mutex_handle->pid != pid) {
652 g_message("%s: We don't own mutex handle %p (owned by %d:%ld, me %d:%ld)", __func__, handle, mutex_handle->pid, mutex_handle->tid, _wapi_getpid (), tid);
659 /* OK, we own this mutex */
660 mutex_handle->recursion--;
662 if(mutex_handle->recursion==0) {
663 _wapi_thread_disown_mutex (handle);
666 g_message("%s: Unlocking mutex handle %p", __func__, handle);
671 _wapi_handle_set_signal_state (handle, TRUE, FALSE);
675 thr_ret = _wapi_handle_unlock_handle (handle);
676 g_assert (thr_ret == 0);
677 pthread_cleanup_pop (0);
682 static gboolean namedmutex_release (gpointer handle)
684 struct _WapiHandle_namedmutex *mutex_handle;
686 pthread_t tid = pthread_self ();
687 pid_t pid = _wapi_getpid ();
689 gboolean ret = FALSE;
691 ok=_wapi_lookup_handle (handle, WAPI_HANDLE_NAMEDMUTEX,
692 (gpointer *)&mutex_handle);
694 g_warning ("%s: error looking up named mutex handle %p",
699 thr_ret = _wapi_handle_lock_shared_handles ();
700 g_assert (thr_ret == 0);
703 g_message("%s: Releasing mutex handle %p", __func__, handle);
706 if (!pthread_equal (mutex_handle->tid, tid) ||
707 mutex_handle->pid != pid) {
709 g_message("%s: We don't own mutex handle %p (owned by %d:%ld, me %d:%ld)", __func__, handle, mutex_handle->pid, mutex_handle->tid, _wapi_getpid (), tid);
716 /* OK, we own this mutex */
717 mutex_handle->recursion--;
719 if(mutex_handle->recursion==0) {
720 _wapi_thread_disown_mutex (handle);
723 g_message("%s: Unlocking mutex handle %p", __func__, handle);
728 _wapi_shared_handle_set_signal_state (handle, TRUE);
732 _wapi_handle_unlock_shared_handles ();
739 * @handle: The mutex handle.
741 * Releases ownership if the mutex handle @handle.
743 * Return value: %TRUE on success, %FALSE otherwise. This function
744 * fails if the calling thread does not own the mutex @handle.
746 gboolean ReleaseMutex(gpointer handle)
750 if (handle == NULL) {
751 SetLastError (ERROR_INVALID_HANDLE);
755 type = _wapi_handle_type (handle);
757 if (mutex_ops[type].release == NULL) {
758 SetLastError (ERROR_INVALID_HANDLE);
762 return(mutex_ops[type].release (handle));
765 gpointer OpenMutex (guint32 access G_GNUC_UNUSED, gboolean inherit G_GNUC_UNUSED, const gunichar2 *name)
773 mono_once (&mutex_ops_once, mutex_ops_init);
775 /* w32 seems to guarantee that opening named objects can't
778 thr_ret = _wapi_namespace_lock ();
779 g_assert (thr_ret == 0);
781 utf8_name = g_utf16_to_utf8 (name, -1, NULL, NULL, NULL);
784 g_message ("%s: Opening named mutex [%s]", __func__, utf8_name);
787 offset = _wapi_search_handle_namespace (WAPI_HANDLE_NAMEDMUTEX,
790 /* The name has already been used for a different
793 SetLastError (ERROR_INVALID_HANDLE);
795 } else if (offset == 0) {
796 /* This name doesn't exist */
797 SetLastError (ERROR_FILE_NOT_FOUND); /* yes, really */
801 /* A new reference to an existing named mutex, so just create
804 handle = _wapi_handle_new_from_offset (WAPI_HANDLE_NAMEDMUTEX, offset,
807 if (handle == _WAPI_HANDLE_INVALID) {
808 g_warning ("%s: error opening named mutex handle", __func__);
809 SetLastError (ERROR_GEN_FAILURE);
815 g_message ("%s: returning named mutex handle %p", __func__, handle);
821 _wapi_namespace_unlock (NULL);