/*
* This is a very specific function whose only purpose is to
* break a given thread from socket syscalls.
*
* This only exists because linux won't fail a call to connect
* if the underlying is closed.
*
* TODO We should cleanup and unify this with the other syscall abort
* facility.
*/
void
mono_thread_info_abort_socket_syscall_for_close (MonoNativeThreadId tid)
{
MonoThreadHazardPointers *hp;
MonoThreadInfo *info;
if (tid == mono_native_thread_id_get () || !mono_threads_core_needs_abort_syscall ())
return;
hp = mono_hazard_pointer_get ();
info = mono_thread_info_lookup (tid); /*info on HP1*/
if (!info)
return;
if (mono_thread_info_run_state (info) > STATE_RUNNING) {
mono_hazard_pointer_clear (hp, 1);
return;
}
mono_thread_info_suspend_lock ();
mono_threads_core_abort_syscall (info);
mono_hazard_pointer_clear (hp, 1);
mono_thread_info_suspend_unlock ();
}
/*
* This is a very specific function whose only purpose is to
* break a given thread from socket syscalls.
*
* This only exists because linux won't fail a call to connect
* if the underlying is closed.
*
* TODO We should cleanup and unify this with the other syscall abort
* facility.
*/
void
mono_thread_info_abort_socket_syscall_for_close (MonoNativeThreadId tid)
{
MonoThreadHazardPointers *hp;
MonoThreadInfo *info;
if (tid == mono_native_thread_id_get () || !mono_threads_core_needs_abort_syscall ())
return;
hp = mono_hazard_pointer_get ();
info = mono_thread_info_lookup (tid);
if (!info)
return;
if (mono_thread_info_run_state (info) == STATE_DETACHED) {
mono_hazard_pointer_clear (hp, 1);
return;
}
mono_thread_info_suspend_lock ();
mono_threads_begin_global_suspend ();
mono_threads_core_abort_syscall (info);
mono_threads_wait_pending_operations ();
mono_hazard_pointer_clear (hp, 1);
mono_threads_end_global_suspend ();
mono_thread_info_suspend_unlock ();
}
/**
Inject an assynchronous call into the target thread. The target thread must be suspended and
only a single async call can be setup for a given suspend cycle.
This async call must cause stack unwinding as the current implementation doesn't save enough state
to resume execution of the top-of-stack function. It's an acceptable limitation since this is
currently used only to deliver exceptions.
*/
void
mono_thread_info_setup_async_call (MonoThreadInfo *info, void (*target_func)(void*), void *user_data)
{
/* An async call can only be setup on an async suspended thread */
g_assert (mono_thread_info_run_state (info) == STATE_ASYNC_SUSPENDED);
/*FIXME this is a bad assert, we probably should do proper locking and fail if one is already set*/
g_assert (!info->async_target);
info->async_target = target_func;
/* This is not GC tracked */
info->user_data = user_data;
}
/*
The return value is only valid until a matching mono_thread_info_resume is called
*/
static MonoThreadInfo*
mono_thread_info_suspend_sync (MonoNativeThreadId tid, gboolean interrupt_kernel, const char **error_condition)
{
MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
MonoThreadInfo *info = mono_thread_info_lookup (tid); /*info on HP1*/
if (!info) {
*error_condition = "Thread not found";
return NULL;
}
MONO_SEM_WAIT_UNITERRUPTIBLE (&info->suspend_semaphore);
/*thread is on the process of detaching*/
if (mono_thread_info_run_state (info) > STATE_RUNNING) {
mono_hazard_pointer_clear (hp, 1);
*error_condition = "Thread is detaching";
return NULL;
}
THREADS_DEBUG ("suspend %x IN COUNT %d\n", tid, info->suspend_count);
if (info->suspend_count) {
++info->suspend_count;
mono_hazard_pointer_clear (hp, 1);
MONO_SEM_POST (&info->suspend_semaphore);
return info;
}
if (!mono_threads_core_suspend (info)) {
MONO_SEM_POST (&info->suspend_semaphore);
mono_hazard_pointer_clear (hp, 1);
*error_condition = "Could not suspend thread";
return NULL;
}
if (interrupt_kernel)
mono_threads_core_interrupt (info);
++info->suspend_count;
info->thread_state |= STATE_SUSPENDED;
MONO_SEM_POST (&info->suspend_semaphore);
return info;
}
/*
The return value is only valid until a matching mono_thread_info_resume is called
*/
static MonoThreadInfo*
mono_thread_info_suspend_sync (MonoNativeThreadId tid, gboolean interrupt_kernel)
{
MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
MonoThreadInfo *info = mono_thread_info_lookup (tid); /*info on HP1*/
if (!info)
return NULL;
EnterCriticalSection (&info->suspend_lock);
/*thread is on the process of detaching*/
if (mono_thread_info_run_state (info) > STATE_RUNNING) {
mono_hazard_pointer_clear (hp, 1);
return NULL;
}
THREADS_DEBUG ("suspend %x IN COUNT %d\n", tid, info->suspend_count);
if (info->suspend_count) {
++info->suspend_count;
mono_hazard_pointer_clear (hp, 1);
LeaveCriticalSection (&info->suspend_lock);
return info;
}
if (!mono_threads_core_suspend (info)) {
LeaveCriticalSection (&info->suspend_lock);
mono_hazard_pointer_clear (hp, 1);
return NULL;
}
if (interrupt_kernel)
mono_threads_core_interrupt (info);
++info->suspend_count;
info->thread_state |= STATE_SUSPENDED;
LeaveCriticalSection (&info->suspend_lock);
mono_hazard_pointer_clear (hp, 1);
return info;
}
static int
restart_threads_until_none_in_managed_allocator (void)
{
SgenThreadInfo *info;
int num_threads_died = 0;
int sleep_duration = -1;
for (;;) {
int restart_count = 0, restarted_count = 0;
/* restart all threads that stopped in the
allocator */
FOREACH_THREAD_SAFE (info) {
gboolean result;
if (info->skip || info->gc_disabled)
continue;
if (mono_thread_info_run_state (info) == STATE_RUNNING && (!info->stack_start || info->in_critical_region || info->info.inside_critical_region ||
is_ip_in_managed_allocator (info->stopped_domain, info->stopped_ip))) {
binary_protocol_thread_restart ((gpointer)mono_thread_info_get_tid (info));
SGEN_LOG (3, "thread %p resumed.", (void*) (size_t) info->info.native_handle);
result = sgen_resume_thread (info);
if (result) {
++restart_count;
} else {
info->skip = 1;
}
} else {
/* we set the stopped_ip to
NULL for threads which
we're not restarting so
that we can easily identify
the others */
info->stopped_ip = NULL;
info->stopped_domain = NULL;
}
} END_FOREACH_THREAD_SAFE
/* if no threads were restarted, we're done */
if (restart_count == 0)
break;
/* wait for the threads to signal their restart */
sgen_wait_for_suspend_ack (restart_count);
if (sleep_duration < 0) {
mono_thread_info_yield ();
sleep_duration = 0;
} else {
g_usleep (sleep_duration);
sleep_duration += 10;
}
/* stop them again */
FOREACH_THREAD (info) {
gboolean result;
if (info->skip || info->stopped_ip == NULL)
continue;
result = sgen_suspend_thread (info);
if (result) {
++restarted_count;
} else {
info->skip = 1;
}
} END_FOREACH_THREAD
/* some threads might have died */
num_threads_died += restart_count - restarted_count;
/* wait for the threads to signal their suspension
again */
sgen_wait_for_suspend_ack (restarted_count);
}
return num_threads_died;
}