SIG_HANDLER_FUNC (static, sigabrt_signal_handler)
{
MonoJitInfo *ji = NULL;
GET_CONTEXT;
if (mono_thread_internal_current ())
ji = mono_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context(ctx));
if (!ji) {
if (mono_chain_signal (SIG_HANDLER_PARAMS))
return;
mono_handle_native_sigsegv (SIGABRT, ctx);
}
}
void CPipeServer::GetJitInfo()
{
void *domain=(void *)ReadQword();
void *address=(void *)ReadQword();
void *jitinfo=mono_jit_info_table_find(domain, address);
WriteQword((UINT_PTR)jitinfo);
if (jitinfo)
{
WriteQword((UINT_PTR)mono_jit_info_get_method(jitinfo));
WriteQword((UINT_PTR)mono_jit_info_get_code_start(jitinfo));
WriteDword((UINT_PTR)mono_jit_info_get_code_size(jitinfo));
}
}
/*
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 = mono_jit_info_table_find (
info->suspend_state.unwind_data [MONO_UNWIND_DATA_DOMAIN],
MONO_CONTEXT_GET_IP (&info->suspend_state.ctx));
if (!ji)
return FALSE;
method = ji->method;
return mono_gc_is_critical_method (method);
}
/*
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);
}
char *
mono_exception_handle_get_native_backtrace (MonoExceptionHandle exc)
{
#ifdef HAVE_BACKTRACE_SYMBOLS
MonoDomain *domain;
MonoArrayHandle arr = MONO_HANDLE_NEW(MonoArray, NULL);
int i, len;
GString *text;
char **messages;
MONO_HANDLE_GET (arr, exc, native_trace_ips);
if (MONO_HANDLE_IS_NULL(arr))
return g_strdup ("");
domain = mono_domain_get ();
len = mono_array_handle_length (arr);
text = g_string_new_len (NULL, len * 20);
uint32_t gchandle;
gpointer *addr = MONO_ARRAY_HANDLE_PIN (arr, gpointer, 0, &gchandle);
MONO_ENTER_GC_SAFE;
messages = backtrace_symbols (addr, len);
MONO_EXIT_GC_SAFE;
mono_gchandle_free_internal (gchandle);
for (i = 0; i < len; ++i) {
gpointer ip;
MONO_HANDLE_ARRAY_GETVAL (ip, arr, gpointer, i);
MonoJitInfo *ji = mono_jit_info_table_find (domain, ip);
if (ji) {
char *msg = mono_debug_print_stack_frame (mono_jit_info_get_method (ji), (char*)ip - (char*)ji->code_start, domain);
g_string_append_printf (text, "%s\n", msg);
g_free (msg);
} else {
g_string_append_printf (text, "%s\n", messages [i]);
}
}
g_free (messages);
return g_string_free (text, FALSE);
#else
return g_strdup ("");
#endif
}
/*
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;
if (info->inside_critical_region)
return TRUE;
ji = mono_jit_info_table_find (
info->suspend_state.unwind_data [MONO_UNWIND_DATA_DOMAIN],
MONO_CONTEXT_GET_IP (&info->suspend_state.ctx));
if (!ji)
return FALSE;
method = mono_jit_info_get_method (ji);
return threads_callbacks.mono_method_is_critical (method);
}
char *
mono_exception_get_native_backtrace (MonoException *exc)
{
#ifdef HAVE_BACKTRACE_SYMBOLS
MonoDomain *domain;
MonoArray *arr = exc->native_trace_ips;
int i, len;
GString *text;
char **messages;
if (!arr)
return g_strdup ("");
domain = mono_domain_get ();
len = mono_array_length (arr);
text = g_string_new_len (NULL, len * 20);
uint32_t gchandle = mono_gchandle_new (&arr->obj, TRUE); /* pinned */
void* addr = mono_array_addr (arr, gpointer, 0);
MONO_ENTER_GC_SAFE;
messages = backtrace_symbols (addr, len);
MONO_EXIT_GC_SAFE;
mono_gchandle_free (gchandle);
for (i = 0; i < len; ++i) {
gpointer ip = mono_array_get (arr, gpointer, i);
MonoJitInfo *ji = mono_jit_info_table_find (mono_domain_get (), (char *)ip);
if (ji) {
char *msg = mono_debug_print_stack_frame (mono_jit_info_get_method (ji), (char*)ip - (char*)ji->code_start, domain);
g_string_append_printf (text, "%s\n", msg);
g_free (msg);
} else {
g_string_append_printf (text, "%s\n", messages [i]);
}
}
g_free (messages);
return g_string_free (text, FALSE);
#else
return g_strdup ("");
#endif
}
/*
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;
if (info->inside_critical_region)
return TRUE;
/* The target thread might be shutting down and the domain might be null, which means no managed code left to run. */
if (!info->suspend_state.unwind_data [MONO_UNWIND_DATA_DOMAIN])
return FALSE;
ji = mono_jit_info_table_find (
info->suspend_state.unwind_data [MONO_UNWIND_DATA_DOMAIN],
MONO_CONTEXT_GET_IP (&info->suspend_state.ctx));
if (!ji)
return FALSE;
method = mono_jit_info_get_method (ji);
return threads_callbacks.mono_method_is_critical (method);
}
static void
SIG_HANDLER_SIGNATURE (sigusr1_signal_handler)
{
gboolean running_managed;
MonoException *exc;
MonoInternalThread *thread = mono_thread_internal_current ();
MonoDomain *domain = mono_domain_get ();
void *ji;
GET_CONTEXT;
if (!thread || !domain)
/* The thread might not have started up yet */
/* FIXME: Specify the synchronization with start_wrapper () in threads.c */
return;
if (thread->thread_dump_requested) {
thread->thread_dump_requested = FALSE;
mono_print_thread_dump (ctx);
}
/*
* This is an async signal, so the code below must not call anything which
* is not async safe. That includes the pthread locking functions. If we
* know that we interrupted managed code, then locking is safe.
*/
/*
* On OpenBSD, ctx can be NULL if we are interrupting poll ().
*/
if (ctx) {
ji = mono_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context(ctx));
running_managed = ji != NULL;
if (mono_debugger_agent_thread_interrupt (ctx, ji))
return;
} else {
running_managed = FALSE;
}
/* We can't do handler block checking from metadata since it requires doing
* a stack walk with context.
*
* FIXME add full-aot support.
*/
#ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
if (!mono_aot_only && ctx) {
MonoThreadUnwindState unwind_state;
if (mono_thread_state_init_from_sigctx (&unwind_state, ctx)) {
if (mono_install_handler_block_guard (&unwind_state)) {
#ifndef HOST_WIN32
/*Clear current thread from been wapi interrupted otherwise things can go south*/
wapi_clear_interruption ();
#endif
return;
}
}
}
#endif
exc = mono_thread_request_interruption (running_managed);
if (!exc)
return;
mono_arch_handle_exception (ctx, exc, FALSE);
}
