[msvc] Update csproj files

[mono.git] / mono / mini / mini-posix.c

diff --git a/mono/mini/mini-posix.c b/mono/mini/mini-posix.c
index f07b84d47f68a2c7cca51efa71532834c7ad5069..ba60bd9934a62f109dc6698bf24ad129796ebf51 100644 (file)
--- 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 <mono/metadata/threads.h>
 #include <mono/metadata/appdomain.h>
 #include <mono/metadata/debug-helpers.h>
-#include <mono/io-layer/io-layer.h>
 #include "mono/metadata/profiler.h"
 #include <mono/metadata/profiler-private.h>
 #include <mono/metadata/mono-config.h>
@@ -75,7 +75,7 @@
 #include <mach/clock.h>
 #endif
 
-#if defined(__native_client__) || defined(HOST_WATCHOS)
+#if defined(HOST_WATCHOS)
 
 void
 mono_runtime_setup_stat_profiler (void)
@@ -315,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 (). */
@@ -326,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_tls_get_jit_tls ())
-               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);
@@ -581,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;
        }
@@ -717,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
@@ -828,33 +854,7 @@ mono_runtime_setup_stat_profiler (void)
 
 #endif
 
-#endif /* defined(__native_client__) || defined(HOST_WATCHOS) */
-
-#if defined(__native_client__)
-
-void
-mono_gdb_render_native_backtraces (pid_t crashed_pid)
-{
-}
-
-#else
-
-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);
-#elif defined(PLATFORM_MACOSX) && HAVE_FORK
-       return (pid_t) 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)
@@ -916,7 +916,7 @@ mono_gdb_render_native_backtraces (pid_t crashed_pid)
 
        commands = fopen (commands_filename, "w");
        if (!commands) {
-       unlink (commands_filename);
+               unlink (commands_filename);
                return;
        }
 
@@ -942,6 +942,7 @@ mono_gdb_render_native_backtraces (pid_t crashed_pid)
        return;
 
 exec:
+       fclose (commands);
        execv (argv [0], (char**)argv);
 
        _exit (-1);
@@ -950,8 +951,6 @@ exec:
 #endif // HAVE_EXECV
 }
 
-#endif /* defined(__native_client__) */
-
 #if !defined (__MACH__)
 
 gboolean