/* Thread function to check that a recursive mutex given in @data is unlocked */ static gpointer rec_mutex_unlocked_thread (gpointer data) { GRecMutex *rec_mutex = (GRecMutex *) data; g_assert_true (g_rec_mutex_trylock (rec_mutex)); return NULL; }
/** * g_static_rec_mutex_trylock: * @mutex: a #GStaticRecMutex to lock. * * Tries to lock @mutex. If @mutex is already locked by another thread, * it immediately returns %FALSE. Otherwise it locks @mutex and returns * %TRUE. If @mutex is already locked by the calling thread, this * functions increases the depth of @mutex and immediately returns * %TRUE. * * Returns: %TRUE, if @mutex could be locked. * * Deprecated: 2.32: Use g_rec_mutex_trylock() */ gboolean g_static_rec_mutex_trylock (GStaticRecMutex* mutex) { GRecMutex *rm; rm = g_static_rec_mutex_get_rec_mutex_impl (mutex); if (g_rec_mutex_trylock (rm)) { mutex->depth++; return TRUE; } else return FALSE; }
/* returns FALSE if cancelled, in which case the lock is not held */ gboolean e_mapi_cancellable_rec_mutex_lock (EMapiCancellableRecMutex *rec_mutex, GCancellable *cancellable, GError **error) { gulong handler_id; gboolean res = TRUE; g_return_val_if_fail (rec_mutex != NULL, FALSE); g_mutex_lock (&rec_mutex->cond_mutex); if (!cancellable) { g_mutex_unlock (&rec_mutex->cond_mutex); g_rec_mutex_lock (&rec_mutex->rec_mutex); return TRUE; } if (g_cancellable_is_cancelled (cancellable)) { if (error && !*error) { /* coverity[unchecked_value] */ g_cancellable_set_error_if_cancelled (cancellable, error); } g_mutex_unlock (&rec_mutex->cond_mutex); return FALSE; } handler_id = g_signal_connect (cancellable, "cancelled", G_CALLBACK (cancellable_rec_mutex_cancelled_cb), rec_mutex); while (!g_rec_mutex_trylock (&rec_mutex->rec_mutex)) { /* recheck once per 10 seconds, just in case */ g_cond_wait_until (&rec_mutex->cond, &rec_mutex->cond_mutex, g_get_monotonic_time () + (10 * G_TIME_SPAN_SECOND)); if (g_cancellable_is_cancelled (cancellable)) { if (error && !*error) g_cancellable_set_error_if_cancelled (cancellable, error); res = FALSE; break; } } g_signal_handler_disconnect (cancellable, handler_id); g_mutex_unlock (&rec_mutex->cond_mutex); return res; }
/** * e_cancellable_rec_mutex_lock: * @rec_mutex: an #ECancellableRecMutex instance * @cancellable: (allow-none): a #GCancellable, or %NULL * * Acquires lock on @rec_mutex. The returned value indicates whether * the lock was acquired, while %FALSE is returned only either or * invalid arguments or the passed in @cancellable had been cancelled. * In case of %NULL @cancellable the function blocks like g_rec_mutex_lock(). * * Returns: %TRUE, if lock had been acquired, %FALSE otherwise * * Since: 3.8 **/ gboolean e_cancellable_rec_mutex_lock (ECancellableRecMutex *rec_mutex, GCancellable *cancellable) { gulong handler_id; gboolean res = TRUE; g_return_val_if_fail (rec_mutex != NULL, FALSE); g_mutex_lock (&rec_mutex->base.cond_mutex); if (!cancellable) { g_mutex_unlock (&rec_mutex->base.cond_mutex); g_rec_mutex_lock (&rec_mutex->rec_mutex); return TRUE; } if (g_cancellable_is_cancelled (cancellable)) { g_mutex_unlock (&rec_mutex->base.cond_mutex); return FALSE; } handler_id = g_signal_connect ( cancellable, "cancelled", G_CALLBACK (cancellable_locks_cancelled_cb), &rec_mutex->base); while (!g_rec_mutex_trylock (&rec_mutex->rec_mutex)) { /* recheck once per 10 seconds, just in case */ g_cond_wait_until ( &rec_mutex->base.cond, &rec_mutex->base.cond_mutex, g_get_monotonic_time () + (10 * G_TIME_SPAN_SECOND)); if (g_cancellable_is_cancelled (cancellable)) { res = FALSE; break; } } g_signal_handler_disconnect (cancellable, handler_id); g_mutex_unlock (&rec_mutex->base.cond_mutex); return res; }
void GRAB_CTX() { g_rec_mutex_trylock(&__ctx_lock); }