X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Fmini-posix.c;h=ba60bd9934a62f109dc6698bf24ad129796ebf51;hb=1db2001526e816a5ca41f1247635cfcb5fca020d;hp=14c13a4c683d03803203ba0b6dcc753605fc7f73;hpb=60b660d2180f2fa8cd4824875f7d88ff7760172b;p=mono.git diff --git a/mono/mini/mini-posix.c b/mono/mini/mini-posix.c index 14c13a4c683..ba60bd9934a 100644 --- a/mono/mini/mini-posix.c +++ b/mono/mini/mini-posix.c @@ -1,5 +1,6 @@ -/* - * mini-posix.c: POSIX signal handling support for Mono. +/** + * \file + * POSIX signal handling support for Mono. * * Authors: * Mono Team (mono-list@lists.ximian.com) @@ -39,7 +40,6 @@ #include #include #include -#include #include "mono/metadata/profiler.h" #include #include @@ -75,7 +75,7 @@ #include #endif -#if defined(__native_client__) || defined(HOST_WATCHOS) +#if defined(HOST_WATCHOS) void mono_runtime_setup_stat_profiler (void) @@ -120,20 +120,6 @@ mono_runtime_cleanup_handlers (void) { } -#if !defined(PLATFORM_MACOSX) -pid_t -mono_runtime_syscall_fork (void) -{ - g_assert_not_reached(); - return 0; -} - -void -mono_gdb_render_native_backtraces (pid_t crashed_pid) -{ -} -#endif - #else static GHashTable *mono_saved_signal_handlers = NULL; @@ -220,7 +206,7 @@ MONO_SIG_HANDLER_FUNC (static, sigabrt_signal_handler) if (!ji) { if (mono_chain_signal (MONO_SIG_HANDLER_PARAMS)) return; - mono_handle_native_sigsegv (SIGABRT, ctx, info); + mono_handle_native_crash ("SIGABRT", ctx, info); } } @@ -254,7 +240,7 @@ per_thread_profiler_hit (void *ctx) if (call_chain_depth == 0) { mono_profiler_stat_hit ((guchar *)mono_arch_ip_from_context (ctx), ctx); } else { - MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id); + MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_tls_get_jit_tls (); int current_frame_index = 1; MonoContext mono_context; guchar *ips [call_chain_depth + 1]; @@ -329,7 +315,7 @@ static gint32 profiler_interrupt_signals_received; MONO_SIG_HANDLER_FUNC (static, profiler_signal_handler) { int old_errno = errno; - int hp_save_index; + MONO_SIG_HANDLER_GET_CONTEXT; /* See the comment in mono_runtime_shutdown_stat_profiler (). */ @@ -340,21 +326,27 @@ MONO_SIG_HANDLER_FUNC (static, profiler_signal_handler) InterlockedIncrement (&profiler_signals_received); - if (mono_thread_info_get_small_id () == -1) - return; //an non-attached thread got the signal + // 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; + } - if (!mono_domain_get () || !mono_native_tls_get_value (mono_jit_tls_id)) - return; //thread in the process of dettaching + // See the comment in sampling_thread_func (). + InterlockedWrite (&mono_thread_info_current ()->profiler_signal_ack, 1); InterlockedIncrement (&profiler_signals_accepted); - hp_save_index = mono_hazard_pointer_save_for_signal_handler (); + int hp_save_index = mono_hazard_pointer_save_for_signal_handler (); mono_thread_info_set_is_async_context (TRUE); per_thread_profiler_hit (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); @@ -595,16 +587,28 @@ static void clock_init (void) { switch (mono_profiler_get_sampling_mode ()) { - case MONO_PROFILER_STAT_MODE_PROCESS: + case MONO_PROFILER_STAT_MODE_PROCESS: { + /* + * If we don't have clock_nanosleep (), measuring the process time + * makes very little sense as we can only use nanosleep () to sleep on + * real time. + */ #ifdef HAVE_CLOCK_NANOSLEEP + struct timespec ts = { 0 }; + /* - * If we don't have clock_nanosleep (), measuring the process time - * makes very little sense as we can only use nanosleep () to sleep on - * real time. + * Some systems (e.g. Windows Subsystem for Linux) declare the + * CLOCK_PROCESS_CPUTIME_ID clock but don't actually support it. For + * those systems, we fall back to CLOCK_MONOTONIC if we get EINVAL. */ - sampling_posix_clock = CLOCK_PROCESS_CPUTIME_ID; - break; + if (clock_nanosleep (CLOCK_PROCESS_CPUTIME_ID, TIMER_ABSTIME, &ts, NULL) != EINVAL) { + sampling_posix_clock = CLOCK_PROCESS_CPUTIME_ID; + break; + } #endif + + // fallthrough + } case MONO_PROFILER_STAT_MODE_REAL: sampling_posix_clock = CLOCK_MONOTONIC; break; default: g_assert_not_reached (); break; } @@ -731,6 +735,14 @@ sampling_thread_func (void *data) /* info should never be this thread as we're a tools thread. */ g_assert (mono_thread_info_get_tid (info) != mono_native_thread_id_get ()); + /* + * Require an ack for the last sampling signal sent to the thread + * so that we don't overflow the signal queue, leading to all sorts + * of problems (e.g. GC STW failing). + */ + if (profiler_signal != SIGPROF && !InterlockedCompareExchange (&info->profiler_signal_ack, 0, 1)) + continue; + mono_threads_pthread_kill (info, profiler_signal); InterlockedIncrement (&profiler_signals_sent); } FOREACH_THREAD_SAFE_END @@ -842,77 +854,102 @@ mono_runtime_setup_stat_profiler (void) #endif -#if !defined(PLATFORM_MACOSX) -pid_t -mono_runtime_syscall_fork () -{ -#if defined(PLATFORM_ANDROID) - /* SYS_fork is defined to be __NR_fork which is not defined in some ndk versions */ - g_assert_not_reached (); - return 0; -#elif defined(SYS_fork) - return (pid_t) syscall (SYS_fork); -#else - g_assert_not_reached (); - return 0; -#endif +#endif /* defined(HOST_WATCHOS) */ + +static gboolean +native_stack_with_gdb (pid_t crashed_pid, const char **argv, FILE *commands, char* commands_filename) +{ + gchar *gdb; + + gdb = g_find_program_in_path ("gdb"); + if (!gdb) + return FALSE; + + argv [0] = gdb; + argv [1] = "-batch"; + argv [2] = "-x"; + argv [3] = commands_filename; + argv [4] = "-nx"; + + fprintf (commands, "attach %ld\n", (long) crashed_pid); + fprintf (commands, "info threads\n"); + fprintf (commands, "thread apply all bt\n"); + + return TRUE; +} + + +static gboolean +native_stack_with_lldb (pid_t crashed_pid, const char **argv, FILE *commands, char* commands_filename) +{ + gchar *lldb; + + lldb = g_find_program_in_path ("lldb"); + if (!lldb) + return FALSE; + + argv [0] = lldb; + argv [1] = "--batch"; + argv [2] = "--source"; + argv [3] = commands_filename; + argv [4] = "--no-lldbinit"; + + fprintf (commands, "process attach --pid %ld\n", (long) crashed_pid); + fprintf (commands, "thread list\n"); + fprintf (commands, "thread backtrace all\n"); + fprintf (commands, "detach\n"); + fprintf (commands, "quit\n"); + + return TRUE; } void mono_gdb_render_native_backtraces (pid_t crashed_pid) { - const char *argv [9]; - char template_ [] = "/tmp/mono-lldb-commands.XXXXXX"; - char buf1 [128]; +#ifdef HAVE_EXECV + const char *argv [10]; FILE *commands; - gboolean using_lldb = FALSE; + char commands_filename [] = "/tmp/mono-gdb-commands.XXXXXX"; - argv [0] = g_find_program_in_path ("gdb"); - if (argv [0] == NULL) { - argv [0] = g_find_program_in_path ("lldb"); - using_lldb = TRUE; - } + if (mkstemp (commands_filename) == -1) + return; - if (argv [0] == NULL) + commands = fopen (commands_filename, "w"); + if (!commands) { + unlink (commands_filename); return; + } - if (using_lldb) { - if (mkstemp (template_) == -1) - return; + memset (argv, 0, sizeof (char*) * 10); - commands = fopen (template_, "w"); +#if defined(PLATFORM_MACOSX) + if (native_stack_with_lldb (crashed_pid, argv, commands, commands_filename)) + goto exec; +#endif - fprintf (commands, "process attach --pid %ld\n", (long) crashed_pid); - fprintf (commands, "thread list\n"); - fprintf (commands, "thread backtrace all\n"); - fprintf (commands, "detach\n"); - fprintf (commands, "quit\n"); + if (native_stack_with_gdb (crashed_pid, argv, commands, commands_filename)) + goto exec; - fflush (commands); - fclose (commands); +#if !defined(PLATFORM_MACOSX) + if (native_stack_with_lldb (crashed_pid, argv, commands, commands_filename)) + goto exec; +#endif - argv [1] = "--source"; - argv [2] = template_; - argv [3] = 0; - } else { - argv [1] = "-ex"; - sprintf (buf1, "attach %ld", (long) crashed_pid); - argv [2] = buf1; - argv [3] = "--ex"; - argv [4] = "info threads"; - argv [5] = "--ex"; - argv [6] = "thread apply all bt"; - argv [7] = "--batch"; - argv [8] = 0; - } + fprintf (stderr, "mono_gdb_render_native_backtraces not supported on this platform, unable to find gdb or lldb\n"); + fclose (commands); + unlink (commands_filename); + return; + +exec: + fclose (commands); execv (argv [0], (char**)argv); - if (using_lldb) - unlink (template_); + _exit (-1); +#else + fprintf (stderr, "mono_gdb_render_native_backtraces not supported on this platform\n"); +#endif // HAVE_EXECV } -#endif -#endif /* __native_client__ */ #if !defined (__MACH__)