/* LOCKING: assumes the GC lock is held (by the stopping thread) */ MONO_SIG_HANDLER_FUNC (static, suspend_handler) { /* * The suspend signal handler potentially uses syscalls that * can set errno, and it calls functions that use the hazard * pointer machinery. Since we're interrupting other code we * must restore those to the values they had when we * interrupted. */ SgenThreadInfo *info; int old_errno = errno; int hp_save_index = mono_hazard_pointer_save_for_signal_handler (); MONO_SIG_HANDLER_GET_CONTEXT; info = mono_thread_info_current (); suspend_thread (info, ctx); mono_hazard_pointer_restore_for_signal_handler (hp_save_index); errno = old_errno; }
MONO_SIG_HANDLER_FUNC (static, profiler_signal_handler) { int old_errno = errno; MONO_SIG_HANDLER_GET_CONTEXT; /* See the comment in mono_runtime_shutdown_stat_profiler (). */ if (mono_native_thread_id_get () == sampling_thread) { mono_atomic_inc_i32 (&profiler_interrupt_signals_received); return; } mono_atomic_inc_i32 (&profiler_signals_received); // Did a non-attached or detaching thread get the signal? if (mono_thread_info_get_small_id () == -1 || !mono_domain_get () || !mono_tls_get_jit_tls ()) { errno = old_errno; return; } // See the comment in sampling_thread_func (). mono_atomic_store_i32 (&mono_thread_info_current ()->profiler_signal_ack, 1); mono_atomic_inc_i32 (&profiler_signals_accepted); int hp_save_index = mono_hazard_pointer_save_for_signal_handler (); mono_thread_info_set_is_async_context (TRUE); MONO_PROFILER_RAISE (sample_hit, (mono_arch_ip_from_context (ctx), ctx)); mono_thread_info_set_is_async_context (FALSE); mono_hazard_pointer_restore_for_signal_handler (hp_save_index); errno = old_errno; mono_chain_signal (MONO_SIG_HANDLER_PARAMS); }
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; }
} /* LOCKING: assumes the GC lock is held (by the stopping thread) */ MONO_SIGNAL_HANDLER_FUNC (static, suspend_handler, (int sig, siginfo_t *siginfo, void *context)) { /* * The suspend signal handler potentially uses syscalls that * can set errno, and it calls functions that use the hazard * pointer machinery. Since we're interrupting other code we * must restore those to the values they had when we * interrupted. */ SgenThreadInfo *info; int old_errno = errno; int hp_save_index = mono_hazard_pointer_save_for_signal_handler (); info = mono_thread_info_current (); suspend_thread (info, context); mono_hazard_pointer_restore_for_signal_handler (hp_save_index); errno = old_errno; } MONO_SIGNAL_HANDLER_FUNC (static, restart_handler, (int sig)) { SgenThreadInfo *info; int old_errno = errno; info = mono_thread_info_current (); info->signal = restart_signal_num;