void*
mono_threads_prepare_blocking (void* stackdata)
{
MonoThreadInfo *info;
if (!mono_threads_is_coop_enabled ())
return NULL;
++coop_do_blocking_count;
info = mono_thread_info_current_unchecked ();
/* If the thread is not attached, it doesn't make sense prepare for suspend. */
if (!info || !mono_thread_info_is_live (info)) {
THREADS_SUSPEND_DEBUG ("PREPARE-BLOCKING failed %p\n", mono_thread_info_get_tid (info));
return NULL;
}
copy_stack_data (info, stackdata);
retry:
++coop_save_count;
mono_threads_get_runtime_callbacks ()->thread_state_init (&info->thread_saved_state [SELF_SUSPEND_STATE_INDEX]);
switch (mono_threads_transition_do_blocking (info)) {
case DoBlockingContinue:
break;
case DoBlockingPollAndRetry:
mono_threads_state_poll ();
goto retry;
}
return info;
}
void*
mono_threads_reset_blocking_start (void* stackdata)
{
MonoThreadInfo *info;
if (!mono_threads_is_coop_enabled ())
return NULL;
++coop_reset_blocking_count;
info = mono_thread_info_current_unchecked ();
/* If the thread is not attached, it doesn't make sense prepare for suspend. */
if (!info || !mono_thread_info_is_live (info))
return NULL;
copy_stack_data (info, stackdata);
switch (mono_threads_transition_abort_blocking (info)) {
case AbortBlockingIgnore:
info->thread_saved_state [SELF_SUSPEND_STATE_INDEX].valid = FALSE;
return NULL;
case AbortBlockingIgnoreAndPoll:
mono_threads_state_poll ();
return NULL;
case AbortBlockingOk:
info->thread_saved_state [SELF_SUSPEND_STATE_INDEX].valid = FALSE;
return info;
case AbortBlockingOkAndPool:
mono_threads_state_poll ();
return info;
default:
g_error ("Unknown thread state");
}
}
static void
check_info (MonoThreadInfo *info, const gchar *action, const gchar *state)
{
if (!info)
g_error ("Cannot %s GC %s region if the thread is not attached", action, state);
if (!mono_thread_info_is_current (info))
g_error ("[%p] Cannot %s GC %s region on a different thread", mono_thread_info_get_tid (info), action, state);
if (!mono_thread_info_is_live (info))
g_error ("[%p] Cannot %s GC %s region if the thread is not live", mono_thread_info_get_tid (info), action, state);
}
static gboolean
sgen_is_thread_in_current_stw (SgenThreadInfo *info, int *reason)
{
/*
A thread explicitly asked to be skiped because it holds no managed state.
This is used by TP and finalizer threads.
FIXME Use an atomic variable for this to avoid everyone taking the GC LOCK.
*/
if (info->client_info.gc_disabled) {
if (reason)
*reason = 1;
return FALSE;
}
/*
We have detected that this thread is failing/dying, ignore it.
FIXME: can't we merge this with thread_is_dying?
*/
if (info->client_info.skip) {
if (reason)
*reason = 2;
return FALSE;
}
/*
Suspending the current thread will deadlock us, bad idea.
*/
if (info == mono_thread_info_current ()) {
if (reason)
*reason = 3;
return FALSE;
}
/*
We can't suspend the workers that will do all the heavy lifting.
FIXME Use some state bit in SgenThreadInfo for this.
*/
if (sgen_thread_pool_is_thread_pool_thread (mono_thread_info_get_tid (info))) {
if (reason)
*reason = 4;
return FALSE;
}
/*
The thread has signaled that it started to detach, ignore it.
FIXME: can't we merge this with skip
*/
if (!mono_thread_info_is_live (info)) {
if (reason)
*reason = 5;
return FALSE;
}
return TRUE;
}
static void
mono_thread_info_suspend_lock_with_info (MonoThreadInfo *info)
{
g_assert (info);
g_assert (mono_thread_info_is_current (info));
g_assert (mono_thread_info_is_live (info));
MONO_ENTER_GC_SAFE_WITH_INFO(info);
int res = mono_os_sem_wait (&global_suspend_semaphore, MONO_SEM_FLAGS_NONE);
g_assert (res != -1);
MONO_EXIT_GC_SAFE_WITH_INFO;
}
static int
restart_threads_until_none_in_managed_allocator (void)
{
int num_threads_died = 0;
int sleep_duration = -1;
for (;;) {
int restart_count = 0, restarted_count = 0;
/* restart all threads that stopped in the
allocator */
FOREACH_THREAD (info) {
gboolean result;
if (info->client_info.skip || info->client_info.gc_disabled || info->client_info.suspend_done)
continue;
if (mono_thread_info_is_live (info) &&
(!info->client_info.stack_start || info->client_info.in_critical_region || info->client_info.info.inside_critical_region ||
is_ip_in_managed_allocator (info->client_info.stopped_domain, info->client_info.stopped_ip))) {
binary_protocol_thread_restart ((gpointer)mono_thread_info_get_tid (info));
SGEN_LOG (3, "thread %p resumed.", (void*) (size_t) info->client_info.info.native_handle);
result = sgen_resume_thread (info);
if (result) {
++restart_count;
} else {
info->client_info.skip = 1;
}
} else {
/* we set the stopped_ip to
NULL for threads which
we're not restarting so
that we can easily identify
the others */
info->client_info.stopped_ip = NULL;
info->client_info.stopped_domain = NULL;
info->client_info.suspend_done = TRUE;
}
} FOREACH_THREAD_END
/* if no threads were restarted, we're done */
if (restart_count == 0)
break;
/* wait for the threads to signal their restart */
sgen_wait_for_suspend_ack (restart_count);
if (sleep_duration < 0) {
mono_thread_info_yield ();
sleep_duration = 0;
} else {
g_usleep (sleep_duration);
sleep_duration += 10;
}
/* stop them again */
FOREACH_THREAD (info) {
gboolean result;
if (info->client_info.skip || info->client_info.stopped_ip == NULL)
continue;
result = sgen_suspend_thread (info);
if (result) {
++restarted_count;
} else {
info->client_info.skip = 1;
}
} FOREACH_THREAD_END
/* some threads might have died */
num_threads_died += restart_count - restarted_count;
/* wait for the threads to signal their suspension
again */
sgen_wait_for_suspend_ack (restarted_count);
}
return num_threads_died;
}
static void
unregister_thread (void *arg)
{
gpointer gc_unsafe_stackdata;
MonoThreadInfo *info;
int small_id;
info = (MonoThreadInfo *) arg;
g_assert (info);
g_assert (mono_thread_info_is_current (info));
g_assert (mono_thread_info_is_live (info));
small_id = info->small_id;
/* We only enter the GC unsafe region, as when exiting this function, the thread
* will be detached, and the current MonoThreadInfo* will be destroyed. */
mono_threads_enter_gc_unsafe_region_unbalanced_with_info (info, &gc_unsafe_stackdata);
THREADS_DEBUG ("unregistering info %p\n", info);
mono_native_tls_set_value (thread_exited_key, GUINT_TO_POINTER (1));
mono_threads_platform_unregister (info);
/*
* TLS destruction order is not reliable so small_id might be cleaned up
* before us.
*/
#ifndef HAVE_KW_THREAD
mono_native_tls_set_value (small_id_key, GUINT_TO_POINTER (info->small_id + 1));
#endif
/*
First perform the callback that requires no locks.
This callback has the potential of taking other locks, so we do it before.
After it completes, the thread remains functional.
*/
if (threads_callbacks.thread_detach)
threads_callbacks.thread_detach (info);
mono_thread_info_suspend_lock_with_info (info);
/*
Now perform the callback that must be done under locks.
This will render the thread useless and non-suspendable, so it must
be done while holding the suspend lock to give no other thread chance
to suspend it.
*/
if (threads_callbacks.thread_unregister)
threads_callbacks.thread_unregister (info);
mono_threads_unregister_current_thread (info);
mono_threads_transition_detach (info);
mono_thread_info_suspend_unlock ();
g_byte_array_free (info->stackdata, /*free_segment=*/TRUE);
/*now it's safe to free the thread info.*/
mono_thread_hazardous_try_free (info, free_thread_info);
/* Pump the HP queue */
mono_thread_hazardous_try_free_some ();
mono_thread_small_id_free (small_id);
}
