gboolean
mono_threads_core_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_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;
}
/*
* This is the function called from the signal handler
*/
gboolean
mono_arch_handle_exception (void *ctx, gpointer obj)
{
#if defined(MONO_CROSS_COMPILE)
g_assert_not_reached ();
#elif defined(MONO_ARCH_USE_SIGACTION)
void *sigctx = ctx;
/*
* Handling the exception in the signal handler is problematic, since the original
* signal is disabled, and we could run arbitrary code though the debugger. So
* resume into the normal stack and do most work there if possible.
*/
MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
guint64 sp = UCONTEXT_GREGS (sigctx) [mips_sp];
/* Pass the ctx parameter in TLS */
mono_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
/* The others in registers */
UCONTEXT_GREGS (sigctx)[mips_a0] = (gsize)obj;
/* Allocate a stack frame */
sp -= 256;
UCONTEXT_GREGS (sigctx)[mips_sp] = sp;
UCONTEXT_REG_PC (sigctx) = (gsize)handle_signal_exception;
return TRUE;
#else
MonoContext mctx;
gboolean result;
mono_sigctx_to_monoctx (ctx, &mctx);
result = mono_handle_exception (&mctx, obj);
/* restore the context so that returning from the signal handler will invoke
* the catch clause
*/
mono_monoctx_to_sigctx (&mctx, ctx);
return result;
#endif
}
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)
{
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);
/* thread_state_init_from_sigctx return FALSE if the current thread is detaching and suspend can't continue. */
current->suspend_can_continue = ret;
MONO_SEM_POST (¤t->begin_suspend_semaphore);
/* This thread is doomed, all we can do is give up and let the suspender recover. */
if (!ret)
return;
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);
}
/**
* mono_arch_handle_exception:
*
* @ctx: saved processor state
* @obj: the exception object
*/
gboolean
mono_arch_handle_exception (void *sigctx, gpointer obj)
{
#if defined(MONO_ARCH_USE_SIGACTION)
MonoContext mctx;
/*
* Handling the exception in the signal handler is problematic, since the original
* signal is disabled, and we could run arbitrary code though the debugger. So
* resume into the normal stack and do most work there if possible.
*/
MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
/* Pass the ctx parameter in TLS */
mono_arch_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
mctx = jit_tls->ex_ctx;
mono_arch_setup_async_callback (&mctx, handle_signal_exception, obj);
mono_monoctx_to_sigctx (&mctx, sigctx);
return TRUE;
#else
MonoContext mctx;
mono_arch_sigctx_to_monoctx (sigctx, &mctx);
if (mono_debugger_handle_exception (&mctx, (MonoObject *)obj))
return TRUE;
mono_handle_exception (&mctx, obj);
mono_arch_monoctx_to_sigctx (&mctx, sigctx);
return TRUE;
#endif
}
void
mono_arch_monoctx_to_sigctx (MonoContext *mctx, void *ctx)
{
mono_monoctx_to_sigctx (mctx, ctx);
}
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;
}
