mono/utils/mono-threads-posix-signals.c

   1 /*
   2  * mono-threads-posix-signals.c: Shared facility for Posix signals support
   3  *
   4  * Author:
   5  *      Ludovic Henry (ludovic@gmail.com)
   6  *
   7  * (C) 2015 Xamarin, Inc
   8  */
   9
  10 #include <config.h>
  11 #include <glib.h>
  12
  13 #include "mono-threads.h"
  14
  15 #if defined(USE_POSIX_BACKEND)
  16
  17 #include <errno.h>
  18 #include <signal.h>
  19
  20 #include "mono-threads-debug.h"
  21
  22 gint
  23 mono_threads_suspend_search_alternative_signal (void)
  24 {
  25 #if !defined (SIGRTMIN)
  26         g_error ("signal search only works with RTMIN");
  27 #else
  28         int i;
  29         /* we try to avoid SIGRTMIN and any one that might have been set already, see bug #75387 */
  30         for (i = SIGRTMIN + 1; i < SIGRTMAX; ++i) {
  31                 struct sigaction sinfo;
  32                 sigaction (i, NULL, &sinfo);
  33                 if (sinfo.sa_handler == SIG_DFL && (void*)sinfo.sa_sigaction == (void*)SIG_DFL) {
  34                         return i;
  35                 }
  36         }
  37         g_error ("Could not find an available signal");
  38 #endif
  39 }
  40
  41 #ifndef __native_client__
  42
  43 static int suspend_signal_num = -1;
  44 static int restart_signal_num = -1;
  45 static int abort_signal_num = -1;
  46
  47 static sigset_t suspend_signal_mask;
  48 static sigset_t suspend_ack_signal_mask;
  49
  50 static void
  51 signal_add_handler (int signo, void (*handler)(int, siginfo_t *, void *), int flags)
  52 {
  53         struct sigaction sa;
  54         int ret;
  55
  56         sa.sa_sigaction = handler;
  57         sigfillset (&sa.sa_mask);
  58         sa.sa_flags = SA_SIGINFO | flags;
  59         ret = sigaction (signo, &sa, NULL);
  60         g_assert (ret != -1);
  61 }
  62
  63 static int
  64 abort_signal_get (void)
  65 {
  66 #if defined(PLATFORM_ANDROID)
  67         return SIGTTIN;
  68 #elif defined (SIGRTMIN)
  69         static int abort_signum = -1;
  70         if (abort_signum == -1)
  71                 abort_signum = mono_threads_suspend_search_alternative_signal ();
  72         return abort_signum;
  73 #elif defined (SIGTTIN)
  74         return SIGTTIN;
  75 #else
  76         g_error ("unable to get abort signal");
  77 #endif
  78 }
  79
  80 static int
  81 suspend_signal_get (void)
  82 {
  83 #ifdef SIGRTMIN
  84         static int suspend_signum = -1;
  85         if (suspend_signum == -1)
  86                 suspend_signum = mono_threads_suspend_search_alternative_signal ();
  87         return suspend_signum;
  88 #else
  89 #if defined(__APPLE__) || defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
  90         return SIGXFSZ;
  91 #else
  92         return SIGPWR;
  93 #endif
  94 #endif
  95 }
  96
  97 static int
  98 restart_signal_get (void)
  99 {
 100 #ifdef SIGRTMIN
 101         static int restart_signum = -1;
 102         if (restart_signum == -1)
 103                 restart_signum = mono_threads_suspend_search_alternative_signal ();
 104         return restart_signum;
 105 #else
 106         return SIGXCPU;
 107 #endif
 108 }
 109
 110 static void
 111 restart_signal_handler (int _dummy, siginfo_t *_info, void *context)
 112 {
 113         MonoThreadInfo *info;
 114         int old_errno = errno;
 115
 116         info = mono_thread_info_current ();
 117         info->signal = restart_signal_num;
 118         errno = old_errno;
 119 }
 120
 121 static void
 122 suspend_signal_handler (int _dummy, siginfo_t *info, void *context)
 123 {
 124         int old_errno = errno;
 125         int hp_save_index = mono_hazard_pointer_save_for_signal_handler ();
 126
 127         MonoThreadInfo *current = mono_thread_info_current ();
 128
 129         THREADS_SUSPEND_DEBUG ("SIGNAL HANDLER FOR %p [%p]\n", mono_thread_info_get_tid (current), (void*)current->native_handle);
 130         if (current->syscall_break_signal) {
 131                 current->syscall_break_signal = FALSE;
 132                 THREADS_SUSPEND_DEBUG ("\tsyscall break for %p\n", mono_thread_info_get_tid (current));
 133                 mono_threads_notify_initiator_of_abort (current);
 134                 goto done;
 135         }
 136
 137         /* Have we raced with self suspend? */
 138         if (!mono_threads_transition_finish_async_suspend (current)) {
 139                 current->suspend_can_continue = TRUE;
 140                 THREADS_SUSPEND_DEBUG ("\tlost race with self suspend %p\n", mono_thread_info_get_tid (current));
 141                 goto done;
 142         }
 143
 144         /*
 145          * If the thread is starting, then thread_state_init_from_sigctx returns FALSE,
 146          * as the thread might have been attached without the domain or lmf having been
 147          * initialized yet.
 148          *
 149          * One way to fix that is to keep the thread suspended (wait for the restart
 150          * signal), and make sgen aware that even if a thread might be suspended, there
 151          * would be cases where you cannot scan its stack/registers. That would in fact
 152          * consist in removing the async suspend compensation, and treat the case directly
 153          * in sgen. That's also how it was done in the sgen specific suspend code.
 154          */
 155
 156         /* thread_state_init_from_sigctx return FALSE if the current thread is starting or detaching and suspend can't continue. */
 157         current->suspend_can_continue = mono_threads_get_runtime_callbacks ()->thread_state_init_from_sigctx (&current->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX], context);
 158
 159         if (!current->suspend_can_continue)
 160                 THREADS_SUSPEND_DEBUG ("\tThread is starting or detaching, failed to capture state %p\n", mono_thread_info_get_tid (current));
 161
 162         /*
 163         Block the restart signal.
 164         We need to block the restart signal while posting to the suspend_ack semaphore or we race to sigsuspend,
 165         which might miss the signal and get stuck.
 166         */
 167         pthread_sigmask (SIG_BLOCK, &suspend_ack_signal_mask, NULL);
 168
 169         /* We're done suspending */
 170         mono_threads_notify_initiator_of_suspend (current);
 171
 172         do {
 173                 current->signal = 0;
 174                 sigsuspend (&suspend_signal_mask);
 175         } while (current->signal != restart_signal_num);
 176
 177         /* Unblock the restart signal. */
 178         pthread_sigmask (SIG_UNBLOCK, &suspend_ack_signal_mask, NULL);
 179
 180         if (current->async_target) {
 181 #if MONO_ARCH_HAS_MONO_CONTEXT
 182                 MonoContext tmp = current->thread_saved_state [ASYNC_SUSPEND_STATE_INDEX].ctx;
 183                 mono_threads_get_runtime_callbacks ()->setup_async_callback (&tmp, current->async_target, current->user_data);
 184                 current->user_data = NULL;
 185                 current->async_target = NULL;
 186                 mono_monoctx_to_sigctx (&tmp, context);
 187 #else
 188                 g_error ("The new interruption machinery requires a working mono-context");
 189 #endif
 190         }
 191
 192         /* We're done resuming */
 193         mono_threads_notify_initiator_of_resume (current);
 194
 195 done:
 196         mono_hazard_pointer_restore_for_signal_handler (hp_save_index);
 197         errno = old_errno;
 198 }
 199
 200 void
 201 mono_threads_suspend_init_signals (void)
 202 {
 203         sigset_t signal_set;
 204
 205         sigemptyset (&signal_set);
 206
 207         /* add suspend signal */
 208         suspend_signal_num = suspend_signal_get ();
 209
 210         signal_add_handler (suspend_signal_num, suspend_signal_handler, SA_RESTART);
 211
 212         sigaddset (&signal_set, suspend_signal_num);
 213
 214         /* add restart signal */
 215         restart_signal_num = restart_signal_get ();
 216
 217         sigfillset (&suspend_signal_mask);
 218         sigdelset (&suspend_signal_mask, restart_signal_num);
 219
 220         sigemptyset (&suspend_ack_signal_mask);
 221         sigaddset (&suspend_ack_signal_mask, restart_signal_num);
 222
 223         signal_add_handler (restart_signal_num, restart_signal_handler, SA_RESTART);
 224
 225         sigaddset (&signal_set, restart_signal_num);
 226
 227         /* add abort signal */
 228         abort_signal_num = abort_signal_get ();
 229
 230         /* the difference between abort and suspend here is made by not
 231          * passing SA_RESTART, meaning we won't restart the syscall when
 232          * receiving a signal */
 233         signal_add_handler (abort_signal_num, suspend_signal_handler, 0);
 234
 235         sigaddset (&signal_set, abort_signal_num);
 236
 237         /* ensure all the new signals are unblocked */
 238         sigprocmask (SIG_UNBLOCK, &signal_set, NULL);
 239 }
 240
 241 gint
 242 mono_threads_suspend_get_suspend_signal (void)
 243 {
 244         g_assert (suspend_signal_num != -1);
 245         return suspend_signal_num;
 246 }
 247
 248 gint
 249 mono_threads_suspend_get_restart_signal (void)
 250 {
 251         g_assert (restart_signal_num != -1);
 252         return restart_signal_num;
 253 }
 254
 255 gint
 256 mono_threads_suspend_get_abort_signal (void)
 257 {
 258         g_assert (abort_signal_num != -1);
 259         return abort_signal_num;
 260 }
 261
 262 #else
 263
 264 void
 265 mono_threads_suspend_init_signals (void)
 266 {
 267         g_assert_not_reached ();
 268 }
 269
 270 gint
 271 mono_threads_suspend_get_suspend_signal (void)
 272 {
 273         return -1;
 274 }
 275
 276 gint
 277 mono_threads_suspend_get_restart_signal (void)
 278 {
 279         return -1;
 280 }
 281
 282 gint
 283 mono_threads_suspend_get_abort_signal (void)
 284 {
 285         return -1;
 286 }
 287
 288 #endif /* __native_client__ */
 289
 290
 291 #endif /* defined(USE_POSIX_BACKEND) */