X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Fmini-posix.c;h=5e574b376097aac3209254f2a36a3c4a5211152f;hb=e68ef38c186896f71b899d9975e245f9124b79d8;hp=8e6646cc77c99efc1c45680045bef393c5bbc337;hpb=2d68253ca7c846736dbf27a812acd11f1c7a1e1f;p=mono.git diff --git a/mono/mini/mini-posix.c b/mono/mini/mini-posix.c index 8e6646cc77c..5e574b37609 100644 --- a/mono/mini/mini-posix.c +++ b/mono/mini/mini-posix.c @@ -39,7 +39,6 @@ #include #include #include -#include #include "mono/metadata/profiler.h" #include #include @@ -59,7 +58,6 @@ #include #include #include -#include #include "mini.h" #include @@ -107,7 +105,8 @@ mono_runtime_install_handlers (void) void mono_runtime_posix_install_handlers(void) { - + /* we still need to ignore SIGPIPE */ + signal (SIGPIPE, SIG_IGN); } void @@ -120,30 +119,20 @@ 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; static struct sigaction * -get_saved_signal_handler (int signo) +get_saved_signal_handler (int signo, gboolean remove) { - if (mono_saved_signal_handlers) + if (mono_saved_signal_handlers) { /* The hash is only modified during startup, so no need for locking */ - return (struct sigaction *)g_hash_table_lookup (mono_saved_signal_handlers, GINT_TO_POINTER (signo)); + struct sigaction *handler = g_hash_table_lookup (mono_saved_signal_handlers, GINT_TO_POINTER (signo)); + if (remove && handler) + g_hash_table_remove (mono_saved_signal_handlers, GINT_TO_POINTER (signo)); + return handler; + } return NULL; } @@ -166,21 +155,14 @@ save_old_signal_handler (int signo, struct sigaction *old_action) handler_to_save->sa_flags = old_action->sa_flags; if (!mono_saved_signal_handlers) - mono_saved_signal_handlers = g_hash_table_new (NULL, NULL); + mono_saved_signal_handlers = g_hash_table_new_full (NULL, NULL, NULL, g_free); g_hash_table_insert (mono_saved_signal_handlers, GINT_TO_POINTER (signo), handler_to_save); } -static void -free_saved_sig_handler_func (gpointer key, gpointer value, gpointer user_data) -{ - g_free (value); -} - static void free_saved_signal_handlers (void) { if (mono_saved_signal_handlers) { - g_hash_table_foreach (mono_saved_signal_handlers, free_saved_sig_handler_func, NULL); g_hash_table_destroy (mono_saved_signal_handlers); mono_saved_signal_handlers = NULL; } @@ -197,7 +179,7 @@ gboolean MONO_SIG_HANDLER_SIGNATURE (mono_chain_signal) { int signal = MONO_SIG_HANDLER_GET_SIGNO (); - struct sigaction *saved_handler = (struct sigaction *)get_saved_signal_handler (signal); + struct sigaction *saved_handler = (struct sigaction *)get_saved_signal_handler (signal, FALSE); if (saved_handler && saved_handler->sa_handler) { if (!(saved_handler->sa_flags & SA_SIGINFO)) { @@ -223,7 +205,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); } } @@ -257,7 +239,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]; @@ -322,18 +304,35 @@ per_thread_profiler_hit (void *ctx) } } +static MonoNativeThreadId sampling_thread; + +static gint32 profiler_signals_sent; +static gint32 profiler_signals_received; +static gint32 profiler_signals_accepted; +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 (). */ + if (mono_native_thread_id_get () == sampling_thread) { + InterlockedIncrement (&profiler_interrupt_signals_received); + return; + } + + InterlockedIncrement (&profiler_signals_received); + if (mono_thread_info_get_small_id () == -1) return; //an non-attached thread got the signal - if (!mono_domain_get () || !mono_native_tls_get_value (mono_jit_tls_id)) + if (!mono_domain_get () || !mono_tls_get_jit_tls ()) return; //thread in the process of dettaching + InterlockedIncrement (&profiler_signals_accepted); + hp_save_index = mono_hazard_pointer_save_for_signal_handler (); mono_thread_info_set_is_async_context (TRUE); @@ -429,7 +428,7 @@ static void remove_signal_handler (int signo) { struct sigaction sa; - struct sigaction *saved_action = get_saved_signal_handler (signo); + struct sigaction *saved_action = get_saved_signal_handler (signo, TRUE); if (!saved_action) { sa.sa_handler = SIG_DFL; @@ -508,6 +507,8 @@ mono_runtime_cleanup_handlers (void) #ifdef HAVE_PROFILER_SIGNAL +static volatile gint32 sampling_thread_running; + #ifdef PLATFORM_MACOSX static clock_serv_t sampling_clock_service; @@ -565,11 +566,10 @@ clock_sleep_ns_abs (guint64 ns_abs) do { ret = clock_sleep (sampling_clock_service, TIME_ABSOLUTE, then, &remain_unused); - } while (ret == KERN_ABORTED); - - if (ret != KERN_SUCCESS) - g_error ("%s: clock_sleep () returned %d", __func__, ret); + if (ret != KERN_SUCCESS && ret != KERN_ABORTED) + g_error ("%s: clock_sleep () returned %d", __func__, ret); + } while (ret == KERN_ABORTED && InterlockedRead (&sampling_thread_running)); } #else @@ -626,7 +626,7 @@ clock_sleep_ns_abs (guint64 ns_abs) if (ret != 0 && ret != EINTR) g_error ("%s: clock_nanosleep () returned %d", __func__, ret); - } while (ret == EINTR); + } while (ret == EINTR && InterlockedRead (&sampling_thread_running)); #else int ret; gint64 diff; @@ -667,21 +667,20 @@ clock_sleep_ns_abs (guint64 ns_abs) if ((ret = nanosleep (&req, NULL)) == -1 && errno != EINTR) g_error ("%s: nanosleep () returned -1, errno = %d", __func__, errno); - } while (ret == -1); + } while (ret == -1 && InterlockedRead (&sampling_thread_running)); #endif } #endif static int profiler_signal; -static MonoNativeThreadId sampling_thread; -static volatile gint32 sampling_thread_running; +static volatile gint32 sampling_thread_exiting; static mono_native_thread_return_t sampling_thread_func (void *data) { mono_threads_attach_tools_thread (); - mono_thread_info_set_name (mono_native_thread_id_get (), "Profiler sampler"); + mono_native_thread_set_name (mono_native_thread_id_get (), "Profiler sampler"); gint64 rate = 1000000000 / mono_profiler_get_sampling_rate (); @@ -718,11 +717,14 @@ sampling_thread_func (void *data) g_assert (mono_thread_info_get_tid (info) != mono_native_thread_id_get ()); mono_threads_pthread_kill (info, profiler_signal); + InterlockedIncrement (&profiler_signals_sent); } FOREACH_THREAD_SAFE_END clock_sleep_ns_abs (sleep); } + InterlockedWrite (&sampling_thread_exiting, 1); + clock_cleanup (); pthread_setschedparam (pthread_self (), old_policy, &old_sched); @@ -736,7 +738,36 @@ void mono_runtime_shutdown_stat_profiler (void) { InterlockedWrite (&sampling_thread_running, 0); - pthread_join (sampling_thread, NULL); + +#ifndef PLATFORM_MACOSX + /* + * There is a slight problem when we're using CLOCK_PROCESS_CPUTIME_ID: If + * we're shutting down and there's largely no activity in the process other + * than waiting for the sampler thread to shut down, it can take upwards of + * 20 seconds (depending on a lot of factors) for us to shut down because + * the sleep progresses very slowly as a result of the low CPU activity. + * + * We fix this by repeatedly sending the profiler signal to the sampler + * thread in order to interrupt the sleep. clock_sleep_ns_abs () will check + * sampling_thread_running upon an interrupt and return immediately if it's + * zero. profiler_signal_handler () has a special case to ignore the signal + * for the sampler thread. + */ + MonoThreadInfo *info; + + // Did it shut down already? + if ((info = mono_thread_info_lookup (sampling_thread))) { + while (!InterlockedRead (&sampling_thread_exiting)) { + mono_threads_pthread_kill (info, profiler_signal); + mono_thread_info_usleep (10 * 1000 /* 10ms */); + } + + // Make sure info can be freed. + mono_hazard_pointer_clear (mono_hazard_pointer_get (), 1); + } +#endif + + mono_native_thread_join (sampling_thread); /* * We can't safely remove the signal handler because we have no guarantee @@ -755,20 +786,29 @@ mono_runtime_setup_stat_profiler (void) * tends to result in awful delivery rates when the application is heavily * loaded. * + * We avoid real-time signals on Android as they're super broken in certain + * API levels (too small sigset_t, nonsensical SIGRTMIN/SIGRTMAX values, + * etc). + * * TODO: On Mac, we should explore using the Mach thread suspend/resume * functions and doing the stack walk from the sampling thread. This would * get us a 100% sampling rate. However, this may interfere with the GC's * STW logic. Could perhaps be solved by taking the suspend lock. */ -#if defined (USE_POSIX_BACKEND) && defined (SIGRTMIN) +#if defined (USE_POSIX_BACKEND) && defined (SIGRTMIN) && !defined (PLATFORM_ANDROID) /* Just take the first real-time signal we can get. */ - profiler_signal = mono_threads_posix_signal_search_alternative (-1); + profiler_signal = mono_threads_suspend_search_alternative_signal (); #else profiler_signal = SIGPROF; #endif add_signal_handler (profiler_signal, profiler_signal_handler, SA_RESTART); + mono_counters_register ("Sampling signals sent", MONO_COUNTER_UINT | MONO_COUNTER_PROFILER | MONO_COUNTER_MONOTONIC, &profiler_signals_sent); + mono_counters_register ("Sampling signals received", MONO_COUNTER_UINT | MONO_COUNTER_PROFILER | MONO_COUNTER_MONOTONIC, &profiler_signals_received); + mono_counters_register ("Sampling signals accepted", MONO_COUNTER_UINT | MONO_COUNTER_PROFILER | MONO_COUNTER_MONOTONIC, &profiler_signals_accepted); + mono_counters_register ("Shutdown signals received", MONO_COUNTER_UINT | MONO_COUNTER_PROFILER | MONO_COUNTER_MONOTONIC, &profiler_interrupt_signals_received); + InterlockedWrite (&sampling_thread_running, 1); mono_native_thread_create (&sampling_thread, sampling_thread_func, NULL); } @@ -787,77 +827,113 @@ 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); +#endif /* defined(__native_client__) || defined(HOST_WATCHOS) */ + +#if defined(__native_client__) + +void +mono_gdb_render_native_backtraces (pid_t crashed_pid) +{ +} + #else - g_assert_not_reached (); - return 0; -#endif + +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__ */ + +#endif /* defined(__native_client__) */ #if !defined (__MACH__)