void
mono_threads_state_poll (void)
{
MonoThreadInfo *info;
g_assert (mono_threads_is_coop_enabled ());
++coop_do_polling_count;
info = mono_thread_info_current_unchecked ();
if (!info)
return;
THREADS_SUSPEND_DEBUG ("FINISH SELF SUSPEND OF %p\n", mono_thread_info_get_tid (info));
/* Fast check for pending suspend requests */
if (!(info->thread_state & (STATE_ASYNC_SUSPEND_REQUESTED | STATE_SELF_SUSPEND_REQUESTED)))
return;
++coop_save_count;
mono_threads_get_runtime_callbacks ()->thread_state_init (&info->thread_saved_state [SELF_SUSPEND_STATE_INDEX]);
/* commit the saved state and notify others if needed */
switch (mono_threads_transition_state_poll (info)) {
case SelfSuspendResumed:
return;
case SelfSuspendWait:
mono_thread_info_wait_for_resume (info);
break;
case SelfSuspendNotifyAndWait:
mono_threads_notify_initiator_of_suspend (info);
mono_thread_info_wait_for_resume (info);
break;
}
}
void
mono_thread_info_end_self_suspend (void)
{
MonoThreadInfo *info;
info = mono_thread_info_current ();
if (!info)
return;
THREADS_SUSPEND_DEBUG ("FINISH SELF SUSPEND OF %p\n", info);
mono_threads_get_runtime_callbacks ()->thread_state_init (&info->thread_saved_state [SELF_SUSPEND_STATE_INDEX]);
/* commit the saved state and notify others if needed */
switch (mono_threads_transition_state_poll (info)) {
case SelfSuspendResumed:
return;
case SelfSuspendWait:
mono_thread_info_wait_for_resume (info);
break;
case SelfSuspendNotifyAndWait:
mono_threads_notify_initiator_of_suspend (info);
mono_thread_info_wait_for_resume (info);
mono_threads_notify_initiator_of_resume (info);
break;
}
}
static void
suspend_signal_handler (int _dummy, siginfo_t *info, void *context)
{
#if defined(__native_client__)
g_assert_not_reached ();
#else
int old_errno = errno;
int hp_save_index = mono_hazard_pointer_save_for_signal_handler ();
MonoThreadInfo *current = mono_thread_info_current ();
gboolean ret;
THREADS_SUSPEND_DEBUG ("SIGNAL HANDLER FOR %p [%p]\n", current, (void*)current->native_handle);
if (current->syscall_break_signal) {
current->syscall_break_signal = FALSE;
THREADS_SUSPEND_DEBUG ("\tsyscall break for %p\n", current);
mono_threads_notify_initiator_of_abort (current);
goto done;
}
/* Have we raced with self suspend? */
if (!mono_threads_transition_finish_async_suspend (current)) {
current->suspend_can_continue = TRUE;
THREADS_SUSPEND_DEBUG ("\tlost race with self suspend %p\n", current);
goto done;
}
ret = mono_threads_get_runtime_callbacks ()->thread_state_init_from_sigctx (¤t->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX], context);
/* thread_state_init_from_sigctx return FALSE if the current thread is detaching and suspend can't continue. */
current->suspend_can_continue = ret;
/*
Block the restart signal.
We need to block the restart signal while posting to the suspend_ack semaphore or we race to sigsuspend,
which might miss the signal and get stuck.
*/
pthread_sigmask (SIG_BLOCK, &suspend_ack_signal_mask, NULL);
/* This thread is doomed, all we can do is give up and let the suspender recover. */
if (!ret) {
THREADS_SUSPEND_DEBUG ("\tThread is dying, failed to capture state %p\n", current);
mono_threads_transition_async_suspend_compensation (current);
/* We're done suspending */
mono_threads_notify_initiator_of_suspend (current);
/* Unblock the restart signal. */
pthread_sigmask (SIG_UNBLOCK, &suspend_ack_signal_mask, NULL);
goto done;
}
/* We're done suspending */
mono_threads_notify_initiator_of_suspend (current);
do {
current->signal = 0;
sigsuspend (&suspend_signal_mask);
} while (current->signal != restart_signal_num);
/* Unblock the restart signal. */
pthread_sigmask (SIG_UNBLOCK, &suspend_ack_signal_mask, NULL);
if (current->async_target) {
#if MONO_ARCH_HAS_MONO_CONTEXT
MonoContext tmp = current->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX].ctx;
mono_threads_get_runtime_callbacks ()->setup_async_callback (&tmp, current->async_target, current->user_data);
current->async_target = current->user_data = NULL;
mono_monoctx_to_sigctx (&tmp, context);
#else
g_error ("The new interruption machinery requires a working mono-context");
#endif
}
/* We're done resuming */
mono_threads_notify_initiator_of_resume (current);
done:
mono_hazard_pointer_restore_for_signal_handler (hp_save_index);
errno = old_errno;
#endif
}
static void
suspend_signal_handler (int _dummy, siginfo_t *info, void *context)
{
int old_errno = errno;
int hp_save_index = mono_hazard_pointer_save_for_signal_handler ();
MonoThreadInfo *current = mono_thread_info_current ();
THREADS_SUSPEND_DEBUG ("SIGNAL HANDLER FOR %p [%p]\n", mono_thread_info_get_tid (current), (void*)current->native_handle);
if (current->syscall_break_signal) {
current->syscall_break_signal = FALSE;
THREADS_SUSPEND_DEBUG ("\tsyscall break for %p\n", mono_thread_info_get_tid (current));
mono_threads_notify_initiator_of_abort (current);
goto done;
}
/* Have we raced with self suspend? */
if (!mono_threads_transition_finish_async_suspend (current)) {
current->suspend_can_continue = TRUE;
THREADS_SUSPEND_DEBUG ("\tlost race with self suspend %p\n", mono_thread_info_get_tid (current));
goto done;
}
/*
* If the thread is starting, then thread_state_init_from_sigctx returns FALSE,
* as the thread might have been attached without the domain or lmf having been
* initialized yet.
*
* One way to fix that is to keep the thread suspended (wait for the restart
* signal), and make sgen aware that even if a thread might be suspended, there
* would be cases where you cannot scan its stack/registers. That would in fact
* consist in removing the async suspend compensation, and treat the case directly
* in sgen. That's also how it was done in the sgen specific suspend code.
*/
/* thread_state_init_from_sigctx return FALSE if the current thread is starting or detaching and suspend can't continue. */
current->suspend_can_continue = mono_threads_get_runtime_callbacks ()->thread_state_init_from_sigctx (¤t->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX], context);
if (!current->suspend_can_continue)
THREADS_SUSPEND_DEBUG ("\tThread is starting or detaching, failed to capture state %p\n", mono_thread_info_get_tid (current));
/*
Block the restart signal.
We need to block the restart signal while posting to the suspend_ack semaphore or we race to sigsuspend,
which might miss the signal and get stuck.
*/
pthread_sigmask (SIG_BLOCK, &suspend_ack_signal_mask, NULL);
/* We're done suspending */
mono_threads_notify_initiator_of_suspend (current);
do {
current->signal = 0;
sigsuspend (&suspend_signal_mask);
} while (current->signal != restart_signal_num);
/* Unblock the restart signal. */
pthread_sigmask (SIG_UNBLOCK, &suspend_ack_signal_mask, NULL);
if (current->async_target) {
#if MONO_ARCH_HAS_MONO_CONTEXT
MonoContext tmp = current->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX].ctx;
mono_threads_get_runtime_callbacks ()->setup_async_callback (&tmp, current->async_target, current->user_data);
current->user_data = NULL;
current->async_target = NULL;
mono_monoctx_to_sigctx (&tmp, context);
#else
g_error ("The new interruption machinery requires a working mono-context");
#endif
}
/* We're done resuming */
mono_threads_notify_initiator_of_resume (current);
done:
mono_hazard_pointer_restore_for_signal_handler (hp_save_index);
errno = old_errno;
}
