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; }