/**
* Removes the current thread from the thread list.
* This must be called from the thread unregister callback and nowhere else.
* The current thread must be passed as TLS might have already been cleaned up.
*/
void
mono_threads_unregister_current_thread (MonoThreadInfo *info)
{
gboolean result;
g_assert (mono_thread_info_get_tid (info) == mono_native_thread_id_get ());
result = mono_thread_info_remove (info);
g_assert (result);
}
static void
boehm_thread_unregister (MonoThreadInfo *p)
{
MonoNativeThreadId tid;
tid = mono_thread_info_get_tid (p);
mono_threads_add_joinable_thread ((gpointer)tid);
}
static gboolean
mono_thread_info_core_resume (MonoThreadInfo *info)
{
gboolean result;
MonoNativeThreadId tid = mono_thread_info_get_tid (info);
if (info->create_suspended) {
/* Have to special case this, as the normal suspend/resume pair are racy, they don't work if he resume is received before the suspend */
info->create_suspended = FALSE;
mono_threads_core_resume_created (info, tid);
return TRUE;
}
MONO_SEM_WAIT_UNITERRUPTIBLE (&info->suspend_semaphore);
THREADS_DEBUG ("resume %x IN COUNT %d\n", tid, info->suspend_count);
if (info->suspend_count <= 0) {
MONO_SEM_POST (&info->suspend_semaphore);
return FALSE;
}
/*
* The theory here is that if we manage to suspend the thread it means it did not
* start cleanup since it take the same lock.
*/
g_assert (mono_thread_info_get_tid (info));
if (--info->suspend_count == 0) {
if (mono_thread_info_suspend_state (info) == STATE_SELF_SUSPENDED) {
MONO_SEM_POST (&info->resume_semaphore);
MONO_SEM_WAIT_UNITERRUPTIBLE (&info->finish_resume_semaphore);
result = TRUE;
} else {
result = mono_threads_core_resume (info);
}
info->thread_state &= ~SUSPEND_STATE_MASK;
} else {
result = TRUE;
}
MONO_SEM_POST (&info->suspend_semaphore);
return result;
}
static void
corgc_thread_unregister (MonoThreadInfo *p)
{
MonoNativeThreadId tid;
tid = mono_thread_info_get_tid (p);
if (p->runtime_thread)
mono_threads_add_joinable_thread ((gpointer)tid);
}
static void
sgen_unified_suspend_restart_world (void)
{
THREADS_STW_DEBUG ("[GC-STW-END] *** BEGIN RESUME ***\n");
FOREACH_THREAD (info) {
int reason = 0;
if (sgen_is_thread_in_current_stw (info, &reason)) {
g_assert (mono_thread_info_begin_resume (info));
THREADS_STW_DEBUG ("[GC-STW-RESUME-WORLD] RESUME thread %p\n", mono_thread_info_get_tid (info));
binary_protocol_thread_restart ((gpointer) mono_thread_info_get_tid (info));
} else {
THREADS_STW_DEBUG ("[GC-STW-RESUME-WORLD] IGNORE thread %p, reason %d\n", mono_thread_info_get_tid (info), reason);
}
} FOREACH_THREAD_END
mono_threads_wait_pending_operations ();
mono_threads_end_global_suspend ();
}
int
mono_threads_pthread_kill (MonoThreadInfo *info, int signum)
{
THREADS_SUSPEND_DEBUG ("sending signal %d to %p[%p]\n", signum, info, mono_thread_info_get_tid (info));
#ifdef USE_TKILL_ON_ANDROID
int result, old_errno = errno;
result = tkill (info->native_handle, signum);
if (result < 0) {
result = errno;
errno = old_errno;
}
return result;
#elif defined(__native_client__)
/* Workaround pthread_kill abort() in NaCl glibc. */
return 0;
#else
return pthread_kill (mono_thread_info_get_tid (info), signum);
#endif
}
static gboolean
sgen_is_thread_in_current_stw (SgenThreadInfo *info, int *reason)
{
/*
A thread explicitly asked to be skiped because it holds no managed state.
This is used by TP and finalizer threads.
FIXME Use an atomic variable for this to avoid everyone taking the GC LOCK.
*/
if (info->client_info.gc_disabled) {
if (reason)
*reason = 1;
return FALSE;
}
/*
We have detected that this thread is failing/dying, ignore it.
FIXME: can't we merge this with thread_is_dying?
*/
if (info->client_info.skip) {
if (reason)
*reason = 2;
return FALSE;
}
/*
Suspending the current thread will deadlock us, bad idea.
*/
if (info == mono_thread_info_current ()) {
if (reason)
*reason = 3;
return FALSE;
}
/*
We can't suspend the workers that will do all the heavy lifting.
FIXME Use some state bit in SgenThreadInfo for this.
*/
if (sgen_thread_pool_is_thread_pool_thread (mono_thread_info_get_tid (info))) {
if (reason)
*reason = 4;
return FALSE;
}
/*
The thread has signaled that it started to detach, ignore it.
FIXME: can't we merge this with skip
*/
if (!mono_thread_info_is_live (info)) {
if (reason)
*reason = 5;
return FALSE;
}
return TRUE;
}
gboolean
sgen_suspend_thread (SgenThreadInfo *info)
{
mach_msg_type_number_t num_state;
thread_state_t state;
kern_return_t ret;
ucontext_t ctx;
mcontext_t mctx;
gpointer stack_start;
state = (thread_state_t) alloca (mono_mach_arch_get_thread_state_size ());
mctx = (mcontext_t) alloca (mono_mach_arch_get_mcontext_size ());
do {
ret = thread_suspend (info->client_info.info.native_handle);
} while (ret == KERN_ABORTED);
if (ret != KERN_SUCCESS)
return FALSE;
do {
ret = mono_mach_arch_get_thread_state (info->client_info.info.native_handle, state, &num_state);
} while (ret == KERN_ABORTED);
if (ret != KERN_SUCCESS)
return FALSE;
mono_mach_arch_thread_state_to_mcontext (state, mctx);
ctx.uc_mcontext = mctx;
info->client_info.stopped_domain = mono_thread_info_tls_get (info, TLS_KEY_DOMAIN);
info->client_info.stopped_ip = (gpointer) mono_mach_arch_get_ip (state);
info->client_info.stack_start = NULL;
stack_start = (char*) mono_mach_arch_get_sp (state) - REDZONE_SIZE;
/* If stack_start is not within the limits, then don't set it in info and we will be restarted. */
if (stack_start >= info->client_info.stack_start_limit && stack_start <= info->client_info.stack_end) {
info->client_info.stack_start = stack_start;
#ifdef USE_MONO_CTX
mono_sigctx_to_monoctx (&ctx, &info->client_info.ctx);
#else
ARCH_COPY_SIGCTX_REGS (&info->client_info.regs, &ctx);
#endif
} else {
g_assert (!info->client_info.stack_start);
}
/* Notify the JIT */
if (mono_gc_get_gc_callbacks ()->thread_suspend_func)
mono_gc_get_gc_callbacks ()->thread_suspend_func (info->client_info.runtime_data, &ctx, NULL);
SGEN_LOG (2, "thread %p stopped at %p stack_start=%p", (void*)(gsize)info->client_info.info.native_handle, info->client_info.stopped_ip, info->client_info.stack_start);
binary_protocol_thread_suspend ((gpointer)mono_thread_info_get_tid (info), info->client_info.stopped_ip);
return TRUE;
}
static void*
register_thread (MonoThreadInfo *info, gpointer baseptr)
{
size_t stsize = 0;
guint8 *staddr = NULL;
int small_id = mono_thread_info_register_small_id ();
gboolean result;
mono_thread_info_set_tid (info, mono_native_thread_id_get ());
info->small_id = small_id;
info->handle = g_new0 (MonoThreadHandle, 1);
mono_refcount_init (info->handle, thread_handle_destroy);
mono_os_event_init (&info->handle->event, FALSE);
mono_os_sem_init (&info->resume_semaphore, 0);
/*set TLS early so SMR works */
mono_native_tls_set_value (thread_info_key, info);
THREADS_DEBUG ("registering info %p tid %p small id %x\n", info, mono_thread_info_get_tid (info), info->small_id);
if (threads_callbacks.thread_register) {
if (threads_callbacks.thread_register (info, baseptr) == NULL) {
// g_warning ("thread registation failed\n");
mono_native_tls_set_value (thread_info_key, NULL);
g_free (info);
return NULL;
}
}
mono_thread_info_get_stack_bounds (&staddr, &stsize);
g_assert (staddr);
g_assert (stsize);
info->stack_start_limit = staddr;
info->stack_end = staddr + stsize;
info->stackdata = g_byte_array_new ();
mono_threads_suspend_register (info);
/*
Transition it before taking any locks or publishing itself to reduce the chance
of others witnessing a detached thread.
We can reasonably expect that until this thread gets published, no other thread will
try to manipulate it.
*/
mono_threads_transition_attach (info);
mono_thread_info_suspend_lock ();
/*If this fail it means a given thread has been registered twice, which doesn't make sense. */
result = mono_thread_info_insert (info);
g_assert (result);
mono_thread_info_suspend_unlock ();
return info;
}
/*
* mono_thread_info_prepare_interrupt:
*
* The state of the thread info interrupt token is set to 'interrupted' which means that :
* - if the thread calls one of the WaitFor functions, the function will return with
* WAIT_IO_COMPLETION instead of waiting
* - if the thread was waiting when this function was called, the wait will be broken
*
* It is possible that the wait functions return WAIT_IO_COMPLETION, but the target thread
* didn't receive the interrupt signal yet, in this case it should call the wait function
* again. This essentially means that the target thread will busy wait until it is ready to
* process the interruption.
*/
MonoThreadInfoInterruptToken*
mono_thread_info_prepare_interrupt (MonoThreadInfo *info)
{
MonoThreadInfoInterruptToken *token;
token = set_interrupt_state (info);
THREADS_INTERRUPT_DEBUG ("interrupt prepare tid %p token %p\n",
mono_thread_info_get_tid (info), token);
return token;
}
static inline void
trace_state_change (const char *transition, MonoThreadInfo *info, int cur_raw_state, int next_state, int suspend_count_delta)
{
check_thread_state (info);
THREADS_STATE_MACHINE_DEBUG ("[%s][%p] %s -> %s (%d -> %d)\n",
transition,
mono_thread_info_get_tid (info),
state_name (get_thread_state (cur_raw_state)),
state_name (next_state),
get_thread_suspend_count (cur_raw_state),
get_thread_suspend_count (cur_raw_state) + suspend_count_delta);
}
int
sgen_thread_handshake (BOOL suspend)
{
int count, result;
SgenThreadInfo *info;
int signum = suspend ? suspend_signal_num : restart_signal_num;
MonoNativeThreadId me = mono_native_thread_id_get ();
count = 0;
FOREACH_THREAD_SAFE (info) {
if (info->joined_stw == suspend)
continue;
info->joined_stw = suspend;
if (mono_native_thread_id_equals (mono_thread_info_get_tid (info), me)) {
continue;
}
if (info->gc_disabled)
continue;
/*if (signum == suspend_signal_num && info->stop_count == global_stop_count)
continue;*/
if (suspend) {
g_assert (!info->doing_handshake);
info->doing_handshake = TRUE;
} else {
g_assert (info->doing_handshake);
info->doing_handshake = FALSE;
}
result = pthread_kill (mono_thread_info_get_tid (info), signum);
if (result == 0) {
count++;
} else {
info->skip = 1;
}
} END_FOREACH_THREAD_SAFE
sgen_wait_for_suspend_ack (count);
return count;
}
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
sgen_suspend_thread (SgenThreadInfo *info)
{
DWORD id = mono_thread_info_get_tid (info);
HANDLE handle = OpenThread (THREAD_ALL_ACCESS, FALSE, id);
CONTEXT context;
DWORD result;
g_assert (id != GetCurrentThreadId ());
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;
}
context.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL;
if (!GetThreadContext (handle, &context)) {
g_assert_not_reached ();
ResumeThread (handle);
CloseHandle (handle);
return FALSE;
}
g_assert (context.ContextFlags & CONTEXT_INTEGER);
g_assert (context.ContextFlags & CONTEXT_CONTROL);
CloseHandle (handle);
info->stopped_ip = (gpointer)context.Eip;
info->stack_start = (char*)context.Esp - REDZONE_SIZE;
info->regs [0] = context.Edi;
info->regs [1] = context.Esi;
info->regs [2] = context.Ebx;
info->regs [3] = context.Edx;
info->regs [4] = context.Ecx;
info->regs [5] = context.Eax;
info->regs [6] = context.Ebp;
info->regs [7] = context.Esp;
info->stopped_regs = &info->regs;
/* Notify the JIT */
if (mono_gc_get_gc_callbacks ()->thread_suspend_func)
mono_gc_get_gc_callbacks ()->thread_suspend_func (info->runtime_data, NULL);
return TRUE;
}
void
mono_threads_suspend_abort_syscall (MonoThreadInfo *info)
{
DWORD id = mono_thread_info_get_tid (info);
HANDLE handle;
handle = OpenThread (THREAD_ALL_ACCESS, FALSE, id);
g_assert (handle);
mono_win32_abort_wait (info, handle, id);
CloseHandle (handle);
}
void
mono_threads_core_abort_syscall (MonoThreadInfo *info)
{
DWORD id = mono_thread_info_get_tid (info);
HANDLE handle;
handle = OpenThread (THREAD_ALL_ACCESS, FALSE, id);
g_assert (handle);
QueueUserAPC ((PAPCFUNC)interrupt_apc, handle, (ULONG_PTR)NULL);
CloseHandle (handle);
}
gboolean
mono_sgen_suspend_thread (SgenThreadInfo *info)
{
DWORD id = mono_thread_info_get_tid (info);
HANDLE handle = OpenThread (THREAD_ALL_ACCESS, FALSE, id);
CONTEXT context;
DWORD result;
g_assert (handle);
result = SuspendThread (handle);
g_assert (result != (DWORD)-1);
if (result == (DWORD)-1) {
CloseHandle (handle);
return FALSE;
}
context.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL;
if (!GetThreadContext (handle, &context)) {
g_assert_not_reached ();
ResumeThread (handle);
CloseHandle (handle);
return FALSE;
}
g_assert (context.ContextFlags & CONTEXT_INTEGER);
g_assert (context.ContextFlags & CONTEXT_CONTROL);
CloseHandle (handle);
info->stopped_domain = NULL; /* FIXME: implement! */
info->stopped_ip = (gpointer)context.Eip;
info->stack_start = (char*)context.Esp - REDZONE_SIZE;
info->regs [0] = context.Edi;
info->regs [1] = context.Esi;
info->regs [2] = context.Ebx;
info->regs [3] = context.Edx;
info->regs [4] = context.Ecx;
info->regs [5] = context.Eax;
info->regs [6] = context.Ebp;
info->regs [7] = context.Esp;
info->stopped_regs = &info->regs;
/* Notify the JIT */
if (mono_gc_get_gc_callbacks ()->thread_suspend_func)
mono_gc_get_gc_callbacks ()->thread_suspend_func (info->runtime_data, NULL);
return TRUE;
}
void
mono_threads_suspend_abort_syscall (MonoThreadInfo *info)
{
DWORD id = mono_thread_info_get_tid (info);
HANDLE handle;
handle = OpenThread (THREAD_ALL_ACCESS, FALSE, id);
g_assert (handle);
THREADS_INTERRUPT_DEBUG ("%06d - Aborting syscall in thread %06d", GetCurrentThreadId (), id);
QueueUserAPC ((PAPCFUNC)abort_apc, handle, (ULONG_PTR)NULL);
CloseHandle (handle);
}
/* Clear the interrupted flag of the current thread, set with
* mono_thread_info_self_interrupt, so it can wait again */
void
mono_thread_info_clear_self_interrupt ()
{
MonoThreadInfo *info;
MonoThreadInfoInterruptToken *previous_token;
info = mono_thread_info_current ();
g_assert (info);
previous_token = (MonoThreadInfoInterruptToken *)InterlockedCompareExchangePointer ((gpointer*) &info->interrupt_token, NULL, INTERRUPT_STATE);
g_assert (previous_token == NULL || previous_token == INTERRUPT_STATE);
THREADS_INTERRUPT_DEBUG ("interrupt clear self tid %p previous_token %p\n", mono_thread_info_get_tid (info), previous_token);
}
static inline void
trace_state_change_with_func (const char *transition, MonoThreadInfo *info, int cur_raw_state, int next_state, int suspend_count_delta, const char *func)
{
check_thread_state (info);
THREADS_STATE_MACHINE_DEBUG ("[%s][%p] %s -> %s (%d -> %d) %s\n",
transition,
mono_thread_info_get_tid (info),
state_name (get_thread_state (cur_raw_state)),
state_name (next_state),
get_thread_suspend_count (cur_raw_state),
get_thread_suspend_count (cur_raw_state) + suspend_count_delta,
func);
CHECKED_BUILD_THREAD_TRANSITION (transition, info, get_thread_state (cur_raw_state), get_thread_suspend_count (cur_raw_state), next_state, suspend_count_delta);
}
void
mono_thread_info_self_interrupt (void)
{
MonoThreadInfo *info;
MonoThreadInfoInterruptToken *token;
info = mono_thread_info_current ();
g_assert (info);
token = set_interrupt_state (info);
g_assert (!token);
THREADS_INTERRUPT_DEBUG ("interrupt self tid %p\n",
mono_thread_info_get_tid (info));
}
gboolean
mono_thread_state_init_from_handle (MonoThreadUnwindState *tctx, MonoThreadInfo *info, void *sigctx)
{
MonoJitTlsData *jit_tls;
void *domain;
MonoLMF *lmf = NULL;
gpointer *addr;
tctx->valid = FALSE;
tctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = NULL;
tctx->unwind_data [MONO_UNWIND_DATA_LMF] = NULL;
tctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = NULL;
if (sigctx == NULL) {
DWORD id = mono_thread_info_get_tid (info);
mono_setup_thread_context (id, &tctx->ctx);
} else {
g_assert (((CONTEXT *)sigctx)->ContextFlags & CONTEXT_INTEGER);
g_assert (((CONTEXT *)sigctx)->ContextFlags & CONTEXT_CONTROL);
mono_sigctx_to_monoctx (sigctx, &tctx->ctx);
}
/* mono_set_jit_tls () sets this */
jit_tls = mono_thread_info_tls_get (info, TLS_KEY_JIT_TLS);
/* SET_APPDOMAIN () sets this */
domain = mono_thread_info_tls_get (info, TLS_KEY_DOMAIN);
/*Thread already started to cleanup, can no longer capture unwind state*/
if (!jit_tls || !domain)
return FALSE;
/*
* The current LMF address is kept in a separate TLS variable, and its hard to read its value without
* arch-specific code. But the address of the TLS variable is stored in another TLS variable which
* can be accessed through MonoThreadInfo.
*/
/* mono_set_lmf_addr () sets this */
addr = mono_thread_info_tls_get (info, TLS_KEY_LMF_ADDR);
if (addr)
lmf = *addr;
tctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = domain;
tctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = jit_tls;
tctx->unwind_data [MONO_UNWIND_DATA_LMF] = lmf;
tctx->valid = TRUE;
return TRUE;
}
gboolean
sgen_resume_thread (SgenThreadInfo *info)
{
DWORD id = mono_thread_info_get_tid (info);
HANDLE handle = OpenThread (THREAD_ALL_ACCESS, FALSE, id);
DWORD result;
g_assert (handle);
result = ResumeThread (handle);
g_assert (result != (DWORD)-1);
CloseHandle (handle);
return result != (DWORD)-1;
}
int
mono_threads_pthread_kill (MonoThreadInfo *info, int signum)
{
#if defined (PLATFORM_ANDROID)
int result, old_errno = errno;
result = tkill (info->native_handle, signum);
if (result < 0) {
result = errno;
errno = old_errno;
}
return result;
#else
return pthread_kill (mono_thread_info_get_tid (info), signum);
#endif
}
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_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;
}
/*
FIXME fix cardtable WB to be out of line and check with the runtime if the target is not the
WB trampoline. Another option is to encode wb ranges in MonoJitInfo, but that is somewhat hard.
*/
static gboolean
is_thread_in_critical_region (MonoThreadInfo *info)
{
MonoMethod *method;
MonoJitInfo *ji;
gpointer stack_start;
MonoThreadUnwindState *state;
if (mono_threads_platform_in_critical_region (mono_thread_info_get_tid (info)))
return TRUE;
/* Are we inside a system critical region? */
if (info->inside_critical_region)
return TRUE;
/* Are we inside a GC critical region? */
if (threads_callbacks.mono_thread_in_critical_region && threads_callbacks.mono_thread_in_critical_region (info)) {
return TRUE;
}
/* The target thread might be shutting down and the domain might be null, which means no managed code left to run. */
state = mono_thread_info_get_suspend_state (info);
if (!state->unwind_data [MONO_UNWIND_DATA_DOMAIN])
return FALSE;
stack_start = MONO_CONTEXT_GET_SP (&state->ctx);
/* altstack signal handler, sgen can't handle them, so we treat them as critical */
if (stack_start < info->stack_start_limit || stack_start >= info->stack_end)
return TRUE;
if (threads_callbacks.ip_in_critical_region)
return threads_callbacks.ip_in_critical_region ((MonoDomain *) state->unwind_data [MONO_UNWIND_DATA_DOMAIN], (char *) MONO_CONTEXT_GET_IP (&state->ctx));
ji = mono_jit_info_table_find (
(MonoDomain *) state->unwind_data [MONO_UNWIND_DATA_DOMAIN],
(char *) MONO_CONTEXT_GET_IP (&state->ctx));
if (!ji)
return FALSE;
method = mono_jit_info_get_method (ji);
return threads_callbacks.mono_method_is_critical (method);
}
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;
}
int
mono_threads_pthread_kill (MonoThreadInfo *info, int signum)
{
#if defined (PLATFORM_ANDROID)
int result, old_errno = errno;
result = tkill (info->native_handle, signum);
if (result < 0) {
result = errno;
errno = old_errno;
}
return result;
#elif defined(__native_client__)
/* Workaround pthread_kill abort() in NaCl glibc. */
return 0;
#else
return pthread_kill (mono_thread_info_get_tid (info), signum);
#endif
}
gboolean
mono_thread_info_resume (MonoNativeThreadId tid)
{
gboolean result = TRUE;
MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
MonoThreadInfo *info = mono_thread_info_lookup (tid); /*info on HP1*/
if (!info)
return FALSE;
if (info->create_suspended) {
/* Have to special case this, as the normal suspend/resume pair are racy, they don't work if he resume is received before the suspend */
info->create_suspended = FALSE;
mono_threads_core_resume_created (info, tid);
return TRUE;
}
MONO_SEM_WAIT_UNITERRUPTIBLE (&info->suspend_semaphore);
THREADS_DEBUG ("resume %x IN COUNT %d\n",tid, info->suspend_count);
if (info->suspend_count <= 0) {
MONO_SEM_POST (&info->suspend_semaphore);
mono_hazard_pointer_clear (hp, 1);
return FALSE;
}
/*
* The theory here is that if we manage to suspend the thread it means it did not
* start cleanup since it take the same lock.
*/
g_assert (mono_thread_info_get_tid (info));
if (--info->suspend_count == 0)
result = mono_thread_info_resume_internal (info);
MONO_SEM_POST (&info->suspend_semaphore);
mono_hazard_pointer_clear (hp, 1);
mono_atomic_store_release (&mono_thread_info_current ()->inside_critical_region, FALSE);
return result;
}
