#include <mono/utils/dtrace.h>
#include <mono/utils/mono-signal-handler.h>
#include <mono/utils/mono-threads.h>
-#include <mono/utils/mono-threads-posix-signals.h>
#include "mini.h"
#include <string.h>
void
mono_runtime_posix_install_handlers(void)
{
-
+ /* we still need to ignore SIGPIPE */
+ signal (SIGPIPE, SIG_IGN);
}
void
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;
}
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;
}
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)) {
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);
}
}
}
}
+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))
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);
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;
#ifdef HAVE_PROFILER_SIGNAL
+static volatile gint32 sampling_thread_running;
+
#ifdef PLATFORM_MACOSX
static clock_serv_t sampling_clock_service;
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
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;
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 ();
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);
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
* 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);
}
void
mono_gdb_render_native_backtraces (pid_t crashed_pid)
{
- const char *argv [9];
+ const char *argv [10];
char template_ [] = "/tmp/mono-lldb-commands.XXXXXX";
char buf1 [128];
FILE *commands;
argv [5] = "--ex";
argv [6] = "thread apply all bt";
argv [7] = "--batch";
- argv [8] = 0;
+ argv [8] = "-nx";
+ argv [9] = 0;
}
execv (argv [0], (char**)argv);
projects / mono.git / blobdiff