static void
suspend_signal_handler (int _dummy, siginfo_t *info, void *context)
{
MonoThreadInfo *current = mono_thread_info_current ();
gboolean ret;
if (current->syscall_break_signal) {
current->syscall_break_signal = FALSE;
return;
}
ret = mono_threads_get_runtime_callbacks ()->thread_state_init_from_sigctx (¤t->suspend_state, context);
g_assert (ret);
MONO_SEM_POST (¤t->suspend_semaphore);
while (MONO_SEM_WAIT (¤t->resume_semaphore) != 0) {
/*if (EINTR != errno) ABORT("sem_wait failed"); */
}
if (current->async_target) {
#if MONO_ARCH_HAS_MONO_CONTEXT
MonoContext tmp = current->suspend_state.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
}
MONO_SEM_POST (¤t->finish_resume_semaphore);
}
static gpointer
mono_threads_enter_gc_safe_region_unbalanced_with_info (MonoThreadInfo *info, gpointer *stackdata)
{
if (!mono_threads_is_coop_enabled ())
return NULL;
++coop_do_blocking_count;
check_info (info, "enter", "safe");
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_with_info (info);
goto retry;
}
return info;
}
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;
}
}
gboolean
mono_threads_core_begin_async_suspend (MonoThreadInfo *info, gboolean interrupt_kernel)
{
kern_return_t ret;
gboolean res;
g_assert (info);
ret = thread_suspend (info->native_handle);
THREADS_SUSPEND_DEBUG ("SUSPEND %p -> %d\n", (void*)info->native_handle, ret);
if (ret != KERN_SUCCESS)
return FALSE;
/* We're in the middle of a self-suspend, resume and register */
if (!mono_threads_transition_finish_async_suspend (info)) {
mono_threads_add_to_pending_operation_set (info);
g_assert (thread_resume (info->native_handle) == KERN_SUCCESS);
THREADS_SUSPEND_DEBUG ("FAILSAFE RESUME/1 %p -> %d\n", (void*)info->native_handle, 0);
//XXX interrupt_kernel doesn't make sense in this case as the target is not in a syscall
return TRUE;
}
res = mono_threads_get_runtime_callbacks ()->
thread_state_init_from_handle (&info->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX], info);
THREADS_SUSPEND_DEBUG ("thread state %p -> %d\n", (void*)info->native_handle, res);
if (res) {
if (interrupt_kernel)
thread_abort (info->native_handle);
} else {
mono_threads_transition_async_suspend_compensation (info);
g_assert (thread_resume (info->native_handle) == KERN_SUCCESS);
THREADS_SUSPEND_DEBUG ("FAILSAFE RESUME/2 %p -> %d\n", (void*)info->native_handle, 0);
}
return res;
}
void*
mono_threads_try_prepare_blocking (void* stackdata)
{
MonoThreadInfo *info;
if (!mono_threads_is_coop_enabled ())
return NULL;
++coop_try_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) || mono_thread_info_current_state (info) == STATE_BLOCKING) {
THREADS_SUSPEND_DEBUG ("PREPARE-TRY-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_thread_info_self_suspend (void)
{
gboolean ret;
MonoThreadInfo *info = mono_thread_info_current ();
if (!info)
return;
MONO_SEM_WAIT_UNITERRUPTIBLE (&info->suspend_semaphore);
THREADS_DEBUG ("self suspend IN COUNT %d\n", info->suspend_count);
g_assert (info->suspend_count == 0);
++info->suspend_count;
info->thread_state |= STATE_SELF_SUSPENDED;
ret = mono_threads_get_runtime_callbacks ()->thread_state_init_from_sigctx (&info->suspend_state, NULL);
g_assert (ret);
MONO_SEM_POST (&info->suspend_semaphore);
MONO_SEM_WAIT_UNITERRUPTIBLE (&info->resume_semaphore);
g_assert (!info->async_target); /*FIXME this should happen normally for suspend. */
MONO_SEM_POST (&info->finish_resume_semaphore);
}
gboolean
mono_threads_core_suspend (MonoThreadInfo *info)
{
DWORD id = mono_thread_info_get_tid (info);
HANDLE handle;
DWORD result;
gboolean res;
g_assert (id != GetCurrentThreadId ());
handle = OpenThread (THREAD_ALL_ACCESS, FALSE, id);
g_assert (handle);
result = SuspendThread (handle);
if (result == (DWORD)-1) {
fprintf (stderr, "could not suspend thread %x (handle %p): %d\n", id, handle, GetLastError ()); fflush (stderr);
CloseHandle (handle);
return FALSE;
}
CloseHandle (handle);
res = mono_threads_get_runtime_callbacks ()->thread_state_init_from_handle (&info->suspend_state, info);
g_assert (res);
return TRUE;
}
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;
}
}
void
mono_thread_info_self_suspend (void)
{
gboolean ret;
MonoThreadInfo *info = mono_thread_info_current ();
if (!info)
return;
EnterCriticalSection (&info->suspend_lock);
THREADS_DEBUG ("self suspend IN COUNT %d\n", info->suspend_count);
g_assert (info->suspend_count == 0);
++info->suspend_count;
info->thread_state |= STATE_SELF_SUSPENDED;
ret = mono_threads_get_runtime_callbacks ()->thread_state_init_from_sigctx (&info->suspend_state, NULL);
g_assert (ret);
LeaveCriticalSection (&info->suspend_lock);
while (MONO_SEM_WAIT (&info->resume_semaphore) != 0) {
/*if (EINTR != errno) ABORT("sem_wait failed"); */
}
g_assert (!info->async_target); /*FIXME this should happen normally for suspend. */
MONO_SEM_POST (&info->finish_resume_semaphore);
}
gboolean
mono_threads_suspend_begin_async_suspend (MonoThreadInfo *info, gboolean interrupt_kernel)
{
DWORD id = mono_thread_info_get_tid (info);
HANDLE handle;
DWORD result;
handle = OpenThread (THREAD_ALL_ACCESS, FALSE, id);
g_assert (handle);
result = SuspendThread (handle);
THREADS_SUSPEND_DEBUG ("SUSPEND %p -> %d\n", (void*)id, ret);
if (result == (DWORD)-1) {
CloseHandle (handle);
return FALSE;
}
/* Suspend logic assumes thread is really suspended before continuing below. Surprisingly SuspendThread */
/* is just an async request to the scheduler, meaning that the suspended thread can continue to run */
/* user mode code until scheduler gets around and process the request. This will cause a thread state race */
/* in mono's thread state machine implementation on Windows. By requesting a threads context after issuing a */
/* suspended request, this will wait until thread is suspended and thread context has been collected */
/* and returned. */
CONTEXT context;
context.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL;
if (!GetThreadContext (handle, &context)) {
CloseHandle (handle);
return FALSE;
}
/* We're in the middle of a self-suspend, resume and register */
if (!mono_threads_transition_finish_async_suspend (info)) {
mono_threads_add_to_pending_operation_set (info);
result = ResumeThread (handle);
g_assert (result == 1);
CloseHandle (handle);
THREADS_SUSPEND_DEBUG ("FAILSAFE RESUME/1 %p -> %d\n", (void*)id, 0);
//XXX interrupt_kernel doesn't make sense in this case as the target is not in a syscall
return TRUE;
}
info->suspend_can_continue = mono_threads_get_runtime_callbacks ()->thread_state_init_from_handle (&info->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX], info, &context);
THREADS_SUSPEND_DEBUG ("thread state %p -> %d\n", (void*)id, res);
if (info->suspend_can_continue) {
if (interrupt_kernel)
mono_win32_interrupt_wait (info, handle, id);
} else {
THREADS_SUSPEND_DEBUG ("FAILSAFE RESUME/2 %p -> %d\n", (void*)info->native_handle, 0);
}
CloseHandle (handle);
return TRUE;
}
gboolean
mono_threads_suspend_begin_async_resume (MonoThreadInfo *info)
{
kern_return_t ret;
if (info->async_target) {
MonoContext tmp = info->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX].ctx;
mach_msg_type_number_t num_state, num_fpstate;
thread_state_t state, fpstate;
ucontext_t uctx;
mcontext_t mctx;
mono_threads_get_runtime_callbacks ()->setup_async_callback (&tmp, info->async_target, info->user_data);
info->user_data = NULL;
info->async_target = (void (*)(void *)) info->user_data;
state = (thread_state_t) alloca (mono_mach_arch_get_thread_state_size ());
fpstate = (thread_state_t) alloca (mono_mach_arch_get_thread_fpstate_size ());
mctx = (mcontext_t) alloca (mono_mach_arch_get_mcontext_size ());
do {
ret = mono_mach_arch_get_thread_states (info->native_handle, state, &num_state, fpstate, &num_fpstate);
} while (ret == KERN_ABORTED);
if (ret != KERN_SUCCESS)
return FALSE;
mono_mach_arch_thread_states_to_mcontext (state, fpstate, mctx);
uctx.uc_mcontext = mctx;
mono_monoctx_to_sigctx (&tmp, &uctx);
mono_mach_arch_mcontext_to_thread_states (mctx, state, fpstate);
do {
ret = mono_mach_arch_set_thread_states (info->native_handle, state, num_state, fpstate, num_fpstate);
} while (ret == KERN_ABORTED);
if (ret != KERN_SUCCESS)
return FALSE;
}
do {
ret = thread_resume (info->native_handle);
} while (ret == KERN_ABORTED);
THREADS_SUSPEND_DEBUG ("RESUME %p -> %d\n", (gpointer)(gsize)info->native_handle, ret);
return ret == KERN_SUCCESS;
}
gboolean
mono_threads_core_suspend (MonoThreadInfo *info)
{
kern_return_t ret;
gboolean res;
g_assert (info);
ret = thread_suspend (info->native_handle);
if (ret != KERN_SUCCESS)
return FALSE;
res = mono_threads_get_runtime_callbacks ()->
thread_state_init_from_handle (&info->suspend_state, mono_thread_info_get_tid (info), info->native_handle);
if (!res)
thread_resume (info->native_handle);
return res;
}
gboolean
mono_threads_suspend_begin_async_resume (MonoThreadInfo *info)
{
DWORD id = mono_thread_info_get_tid (info);
HANDLE handle;
DWORD result;
handle = OpenThread (THREAD_ALL_ACCESS, FALSE, id);
g_assert (handle);
if (info->async_target) {
MonoContext ctx;
CONTEXT context;
gboolean res;
ctx = info->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX].ctx;
mono_threads_get_runtime_callbacks ()->setup_async_callback (&ctx, info->async_target, info->user_data);
info->async_target = info->user_data = NULL;
context.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL;
if (!GetThreadContext (handle, &context)) {
CloseHandle (handle);
return FALSE;
}
g_assert (context.ContextFlags & CONTEXT_INTEGER);
g_assert (context.ContextFlags & CONTEXT_CONTROL);
mono_monoctx_to_sigctx (&ctx, &context);
context.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL;
res = SetThreadContext (handle, &context);
if (!res) {
CloseHandle (handle);
return FALSE;
}
}
result = ResumeThread (handle);
CloseHandle (handle);
return result != (DWORD)-1;
}
gboolean
mono_threads_core_begin_async_suspend (MonoThreadInfo *info, gboolean interrupt_kernel)
{
DWORD id = mono_thread_info_get_tid (info);
HANDLE handle;
DWORD result;
gboolean res;
handle = OpenThread (THREAD_ALL_ACCESS, FALSE, id);
g_assert (handle);
result = SuspendThread (handle);
THREADS_SUSPEND_DEBUG ("SUSPEND %p -> %d\n", (void*)id, ret);
if (result == (DWORD)-1) {
CloseHandle (handle);
return FALSE;
}
/* We're in the middle of a self-suspend, resume and register */
if (!mono_threads_transition_finish_async_suspend (info)) {
mono_threads_add_to_pending_operation_set (info);
result = ResumeThread (handle);
g_assert (result == 1);
CloseHandle (handle);
THREADS_SUSPEND_DEBUG ("FAILSAFE RESUME/1 %p -> %d\n", (void*)id, 0);
//XXX interrupt_kernel doesn't make sense in this case as the target is not in a syscall
return TRUE;
}
res = mono_threads_get_runtime_callbacks ()->thread_state_init_from_handle (&info->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX], info);
THREADS_SUSPEND_DEBUG ("thread state %p -> %d\n", (void*)id, res);
if (res) {
//FIXME do we need to QueueUserAPC on this case?
if (interrupt_kernel)
QueueUserAPC ((PAPCFUNC)interrupt_apc, handle, (ULONG_PTR)NULL);
} else {
mono_threads_transition_async_suspend_compensation (info);
result = ResumeThread (handle);
g_assert (result == 1);
THREADS_SUSPEND_DEBUG ("FAILSAFE RESUME/2 %p -> %d\n", (void*)info->native_handle, 0);
}
CloseHandle (handle);
return res;
}
gboolean
mono_threads_core_begin_async_resume (MonoThreadInfo *info)
{
kern_return_t ret;
if (info->async_target) {
MonoContext tmp = info->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX].ctx;
mach_msg_type_number_t num_state;
thread_state_t state;
ucontext_t uctx;
mcontext_t mctx;
mono_threads_get_runtime_callbacks ()->setup_async_callback (&tmp, info->async_target, info->user_data);
info->user_data = NULL;
info->async_target = (void (*)(void *)) info->user_data;
state = (thread_state_t) alloca (mono_mach_arch_get_thread_state_size ());
mctx = (mcontext_t) alloca (mono_mach_arch_get_mcontext_size ());
ret = mono_mach_arch_get_thread_state (info->native_handle, state, &num_state);
if (ret != KERN_SUCCESS)
return FALSE;
mono_mach_arch_thread_state_to_mcontext (state, mctx);
#ifdef TARGET_ARM64
g_assert_not_reached ();
#else
uctx.uc_mcontext = mctx;
#endif
mono_monoctx_to_sigctx (&tmp, &uctx);
mono_mach_arch_mcontext_to_thread_state (mctx, state);
ret = mono_mach_arch_set_thread_state (info->native_handle, state, num_state);
if (ret != KERN_SUCCESS)
return FALSE;
}
ret = thread_resume (info->native_handle);
THREADS_SUSPEND_DEBUG ("RESUME %p -> %d\n", (void*)info->native_handle, ret);
return ret == KERN_SUCCESS;
}
gboolean
mono_threads_suspend_begin_async_suspend (MonoThreadInfo *info, gboolean interrupt_kernel)
{
kern_return_t ret;
g_assert (info);
do {
ret = thread_suspend (info->native_handle);
} while (ret == KERN_ABORTED);
THREADS_SUSPEND_DEBUG ("SUSPEND %p -> %d\n", (gpointer)(gsize)info->native_handle, ret);
if (ret != KERN_SUCCESS)
return FALSE;
if (!mono_threads_transition_finish_async_suspend (info)) {
/* We raced with self-suspend and lost. Resume the native
* thread. It is still self-suspended, waiting to be resumed.
* So suspend can continue.
*/
do {
ret = thread_resume (info->native_handle);
} while (ret == KERN_ABORTED);
g_assert (ret == KERN_SUCCESS);
info->suspend_can_continue = TRUE;
THREADS_SUSPEND_DEBUG ("\tlost race with self suspend %p\n", (gpointer)(gsize)info->native_handle);
g_assert (mono_threads_is_hybrid_suspension_enabled ());
//XXX interrupt_kernel doesn't make sense in this case as the target is not in a syscall
return TRUE;
}
info->suspend_can_continue = mono_threads_get_runtime_callbacks ()->
thread_state_init_from_handle (&info->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX], info, NULL);
THREADS_SUSPEND_DEBUG ("thread state %p -> %d\n", (gpointer)(gsize)info->native_handle, ret);
if (info->suspend_can_continue) {
if (interrupt_kernel)
thread_abort (info->native_handle);
} else {
THREADS_SUSPEND_DEBUG ("FAILSAFE RESUME/2 %p -> %d\n", (gpointer)(gsize)info->native_handle, 0);
}
return TRUE;
}
gboolean
mono_threads_core_resume (MonoThreadInfo *info)
{
kern_return_t ret;
if (info->async_target) {
MonoContext tmp = info->suspend_state.ctx;
mach_msg_type_number_t num_state;
thread_state_t state;
ucontext_t uctx;
mcontext_t mctx;
mono_threads_get_runtime_callbacks ()->setup_async_callback (&tmp, info->async_target, info->user_data);
info->async_target = info->user_data = NULL;
state = (thread_state_t) alloca (mono_mach_arch_get_thread_state_size ());
mctx = (mcontext_t) alloca (mono_mach_arch_get_mcontext_size ());
ret = mono_mach_arch_get_thread_state (info->native_handle, state, &num_state);
if (ret != KERN_SUCCESS)
return FALSE;
mono_mach_arch_thread_state_to_mcontext (state, mctx);
#ifdef TARGET_ARM64
g_assert_not_reached ();
#else
uctx.uc_mcontext = mctx;
#endif
mono_monoctx_to_sigctx (&tmp, &uctx);
mono_mach_arch_mcontext_to_thread_state (mctx, state);
ret = mono_mach_arch_set_thread_state (info->native_handle, state, num_state);
if (ret != KERN_SUCCESS)
return FALSE;
}
ret = thread_resume (info->native_handle);
return ret == KERN_SUCCESS;
}
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;
}