/* 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); }
