static void
restore_soft_guard_pages (void)
{
MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
if (jit_tls->stack_ovf_guard_base)
mono_mprotect (jit_tls->stack_ovf_guard_base, jit_tls->stack_ovf_guard_size, MONO_MMAP_NONE);
}
/*
* 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 ();
#else
MonoJitTlsData *jit_tls;
void *sigctx = ctx;
/*
* Resume into the normal stack and handle the exception there.
*/
jit_tls = mono_tls_get_jit_tls ();
/* Pass the ctx parameter in TLS */
mono_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
/* The others in registers */
UCONTEXT_REG_R0 (sigctx) = (gsize)obj;
UCONTEXT_REG_PC (sigctx) = (gsize)handle_signal_exception;
UCONTEXT_REG_SP (sigctx) = UCONTEXT_REG_SP (sigctx) - MONO_ARCH_REDZONE_SIZE;
#endif
return TRUE;
}
/* mono_chain_signal:
*
* Call the original signal handler for the signal given by the arguments, which
* should be the same as for a signal handler. Returns TRUE if the original handler
* was called, false otherwise.
*/
gboolean
MONO_SIG_HANDLER_SIGNATURE (mono_chain_signal)
{
MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
jit_tls->mono_win_chained_exception_needs_run = TRUE;
return TRUE;
}
gboolean
mono_arch_handle_exception (void *sigctx, gpointer obj)
{
#if defined(MONO_ARCH_USE_SIGACTION)
MonoContext mctx;
ucontext_t *ctx = (ucontext_t*)sigctx;
/*
* 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_tls_get_jit_tls ();
/* Pass the ctx parameter in TLS */
mono_sigctx_to_monoctx (ctx, &jit_tls->ex_ctx);
mctx = jit_tls->ex_ctx;
mono_setup_async_callback (&mctx, handle_signal_exception, obj);
mono_monoctx_to_sigctx (&mctx, sigctx);
return TRUE;
#elif defined (TARGET_WIN32)
MonoContext mctx;
MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
struct sigcontext *ctx = (struct sigcontext *)sigctx;
mono_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
mctx = jit_tls->ex_ctx;
mono_setup_async_callback (&mctx, handle_signal_exception, obj);
mono_monoctx_to_sigctx (&mctx, sigctx);
return TRUE;
#else
MonoContext mctx;
mono_sigctx_to_monoctx (sigctx, &mctx);
mono_handle_exception (&mctx, obj);
mono_monoctx_to_sigctx (&mctx, sigctx);
return TRUE;
#endif
}
/*
* handle_exception:
*
* Called by resuming from a signal handler.
*/
static void
handle_signal_exception (gpointer obj)
{
MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
MonoContext ctx;
memcpy (&ctx, &jit_tls->ex_ctx, sizeof (MonoContext));
mono_handle_exception (&ctx, obj);
mono_restore_context (&ctx);
}
/* Special hack to workaround the fact that the
* when the SEH handler is called the stack is
* to small to recover.
*
* Stack walking part of this method is from mono_handle_exception
*
* The idea is simple;
* - walk the stack to free some space (64k)
* - set esp to new stack location
* - call mono_arch_handle_exception with stack overflow exception
* - set esp to SEH handlers stack
* - done
*/
static void
win32_handle_stack_overflow (EXCEPTION_POINTERS* ep, struct sigcontext *sctx)
{
SYSTEM_INFO si;
DWORD page_size;
MonoDomain *domain = mono_domain_get ();
MonoJitInfo rji;
MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
MonoLMF *lmf = jit_tls->lmf;
MonoContext initial_ctx;
MonoContext ctx;
guint32 free_stack = 0;
StackFrameInfo frame;
mono_sigctx_to_monoctx (sctx, &ctx);
/* get our os page size */
GetSystemInfo(&si);
page_size = si.dwPageSize;
/* Let's walk the stack to recover
* the needed stack space (if possible)
*/
memset (&rji, 0, sizeof (rji));
initial_ctx = ctx;
free_stack = (guint8*)(MONO_CONTEXT_GET_BP (&ctx)) - (guint8*)(MONO_CONTEXT_GET_BP (&initial_ctx));
/* try to free 64kb from our stack */
do {
MonoContext new_ctx;
mono_arch_unwind_frame (domain, jit_tls, &rji, &ctx, &new_ctx, &lmf, NULL, &frame);
if (!frame.ji) {
g_warning ("Exception inside function without unwind info");
g_assert_not_reached ();
}
if (frame.ji != (gpointer)-1) {
free_stack = (guint8*)(MONO_CONTEXT_GET_BP (&ctx)) - (guint8*)(MONO_CONTEXT_GET_BP (&initial_ctx));
}
/* todo: we should call abort if ji is -1 */
ctx = new_ctx;
} while (free_stack < 64 * 1024 && frame.ji != (gpointer) -1);
mono_monoctx_to_sigctx (&ctx, sctx);
/* todo: install new stack-guard page */
/* use the new stack and call mono_arch_handle_exception () */
restore_stack (sctx);
}
/*
* Unhandled Exception Filter
* Top-level per-process exception handler.
*/
LONG CALLBACK seh_vectored_exception_handler(EXCEPTION_POINTERS* ep)
{
EXCEPTION_RECORD* er;
CONTEXT* ctx;
LONG res;
MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
/* If the thread is not managed by the runtime return early */
if (!jit_tls)
return EXCEPTION_CONTINUE_SEARCH;
jit_tls->mono_win_chained_exception_needs_run = FALSE;
res = EXCEPTION_CONTINUE_EXECUTION;
er = ep->ExceptionRecord;
ctx = ep->ContextRecord;
switch (er->ExceptionCode) {
case EXCEPTION_STACK_OVERFLOW:
win32_handle_stack_overflow (ep, ctx);
break;
case EXCEPTION_ACCESS_VIOLATION:
W32_SEH_HANDLE_EX(segv);
break;
case EXCEPTION_ILLEGAL_INSTRUCTION:
W32_SEH_HANDLE_EX(ill);
break;
case EXCEPTION_INT_DIVIDE_BY_ZERO:
case EXCEPTION_INT_OVERFLOW:
case EXCEPTION_FLT_DIVIDE_BY_ZERO:
case EXCEPTION_FLT_OVERFLOW:
case EXCEPTION_FLT_UNDERFLOW:
case EXCEPTION_FLT_INEXACT_RESULT:
W32_SEH_HANDLE_EX(fpe);
break;
default:
jit_tls->mono_win_chained_exception_needs_run = TRUE;
break;
}
if (jit_tls->mono_win_chained_exception_needs_run) {
/* Don't copy context back if we chained exception
* as the handler may have modfied the EXCEPTION_POINTERS
* directly. We don't pass sigcontext to chained handlers.
* Return continue search so the UnhandledExceptionFilter
* can correctly chain the exception.
*/
res = EXCEPTION_CONTINUE_SEARCH;
}
return res;
}
/*
* This is the function called from the signal handler
*/
gboolean
mono_arch_handle_exception (void *ctx, gpointer obj)
{
#if defined(MONO_CROSS_COMPILE) || !defined(MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX)
g_assert_not_reached ();
#elif defined(MONO_ARCH_USE_SIGACTION)
arm_ucontext *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_tls_get_jit_tls ();
guint64 sp = UCONTEXT_REG_SP (sigctx);
/* Pass the ctx parameter in TLS */
mono_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
/* The others in registers */
UCONTEXT_REG_R0 (sigctx) = (gsize)obj;
/* Allocate a stack frame */
sp -= 16;
UCONTEXT_REG_SP (sigctx) = sp;
UCONTEXT_REG_PC (sigctx) = (gsize)get_handle_signal_exception_addr ();
#ifdef UCONTEXT_REG_CPSR
if ((gsize)UCONTEXT_REG_PC (sigctx) & 1)
/* Transition to thumb */
UCONTEXT_REG_CPSR (sigctx) |= (1 << 5);
else
/* Transition to ARM */
UCONTEXT_REG_CPSR (sigctx) &= ~(1 << 5);
#endif
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
}
static void
altstack_handle_and_restore (MonoContext *ctx, gpointer obj, gboolean stack_ovf)
{
MonoContext mctx;
mctx = *ctx;
mono_handle_exception (&mctx, obj);
if (stack_ovf) {
MonoJitTlsData *jit_tls = (MonoJitTlsData *) mono_tls_get_jit_tls ();
jit_tls->stack_ovf_pending = 1;
prepare_for_guard_pages (&mctx);
}
mono_restore_context (&mctx);
}
static MonoObject*
restore_soft_guard_pages ()
{
MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
if (jit_tls->stack_ovf_guard_base)
mono_mprotect (jit_tls->stack_ovf_guard_base, jit_tls->stack_ovf_guard_size, MONO_MMAP_NONE);
if (jit_tls->stack_ovf_pending) {
MonoDomain *domain = mono_domain_get ();
jit_tls->stack_ovf_pending = 0;
return (MonoObject *) domain->stack_overflow_ex;
}
return NULL;
}
gboolean
mono_arch_handle_exception (void *ctx, gpointer obj)
{
#if defined(MONO_ARCH_USE_SIGACTION) && defined(UCONTEXT_REG_Rn)
/*
* 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_tls_get_jit_tls ();
mgreg_t sp;
void *sigctx = ctx;
int frame_size;
void *uc = sigctx;
/* Pass the ctx parameter in TLS */
mono_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
/* The others in registers */
UCONTEXT_REG_Rn (sigctx, PPC_FIRST_ARG_REG) = (gsize)obj;
/* Allocate a stack frame below the red zone */
/* Similar to mono_arch_handle_altstack_exception () */
frame_size = 224;
frame_size += 15;
frame_size &= ~15;
sp = (mgreg_t)(UCONTEXT_REG_Rn(uc, 1) & ~15);
sp = (mgreg_t)(sp - frame_size);
UCONTEXT_REG_Rn(uc, 1) = (mgreg_t)sp;
setup_ucontext_return (uc, 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
}
/*
* 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_tls_get_jit_tls ();
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
}
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);
}
