rts/posix/Signals.c

   1 /* -----------------------------------------------------------------------------
   2  *
   3  * (c) The GHC Team, 1998-2005
   4  *
   5  * Signal processing / handling.
   6  *
   7  * ---------------------------------------------------------------------------*/
   8
   9 #include "PosixSource.h"
  10 #include "Rts.h"
  11
  12 #include "Schedule.h"
  13 #include "RtsSignals.h"
  14 #include "Signals.h"
  15 #include "RtsUtils.h"
  16 #include "Prelude.h"
  17 #include "Stable.h"
  18
  19 #ifdef alpha_HOST_ARCH
  20 # if defined(linux_HOST_OS)
  21 #  include <asm/fpu.h>
  22 # else
  23 #  include <machine/fpu.h>
  24 # endif
  25 #endif
  26
  27 #ifdef HAVE_UNISTD_H
  28 # include <unistd.h>
  29 #endif
  30
  31 #ifdef HAVE_SIGNAL_H
  32 # include <signal.h>
  33 #endif
  34
  35 #ifdef HAVE_ERRNO_H
  36 # include <errno.h>
  37 #endif
  38
  39 #include <stdlib.h>
  40 #include <string.h>
  41
  42 /* This curious flag is provided for the benefit of the Haskell binding
  43  * to POSIX.1 to control whether or not to include SA_NOCLDSTOP when
  44  * installing a SIGCHLD handler.
  45  */
  46 HsInt nocldstop = 0;
  47
  48 /* -----------------------------------------------------------------------------
  49  * The table of signal handlers
  50  * -------------------------------------------------------------------------- */
  51
  52 #if defined(RTS_USER_SIGNALS)
  53
  54 /* SUP: The type of handlers is a little bit, well, doubtful... */
  55 StgInt *signal_handlers = NULL; /* Dynamically grown array of signal handlers */
  56 static StgInt nHandlers = 0;    /* Size of handlers array */
  57
  58 static nat n_haskell_handlers = 0;
  59
  60 /* -----------------------------------------------------------------------------
  61  * Allocate/resize the table of signal handlers.
  62  * -------------------------------------------------------------------------- */
  63
  64 static void
  65 more_handlers(int sig)
  66 {
  67     StgInt i;
  68
  69     if (sig < nHandlers)
  70         return;
  71
  72     if (signal_handlers == NULL)
  73         signal_handlers = (StgInt *)stgMallocBytes((sig + 1) * sizeof(StgInt), "more_handlers");
  74     else
  75         signal_handlers = (StgInt *)stgReallocBytes(signal_handlers, (sig + 1) * sizeof(StgInt), "more_handlers");
  76
  77     for(i = nHandlers; i <= sig; i++)
  78         // Fill in the new slots with default actions
  79         signal_handlers[i] = STG_SIG_DFL;
  80
  81     nHandlers = sig + 1;
  82 }
  83
  84 // Here's the pipe into which we will send our signals
  85 static int io_manager_pipe = -1;
  86
  87 #define IO_MANAGER_WAKEUP 0xff
  88 #define IO_MANAGER_DIE    0xfe
  89
  90 void
  91 setIOManagerPipe (int fd)
  92 {
  93     // only called when THREADED_RTS, but unconditionally
  94     // compiled here because GHC.Conc depends on it.
  95     if (io_manager_pipe < 0) {
  96         io_manager_pipe = fd;
  97     }
  98 }
  99
 100 #if defined(THREADED_RTS)
 101 void
 102 ioManagerWakeup (void)
 103 {
 104     int r;
 105     // Wake up the IO Manager thread by sending a byte down its pipe
 106     if (io_manager_pipe >= 0) {
 107         StgWord8 byte = (StgWord8)IO_MANAGER_WAKEUP;
 108         r = write(io_manager_pipe, &byte, 1);
 109         if (r == -1) { sysErrorBelch("ioManagerWakeup: write"); }
 110     }
 111 }
 112
 113 void
 114 ioManagerDie (void)
 115 {
 116     int r;
 117     // Ask the IO Manager thread to exit
 118     if (io_manager_pipe >= 0) {
 119         StgWord8 byte = (StgWord8)IO_MANAGER_DIE;
 120         r = write(io_manager_pipe, &byte, 1);
 121         if (r == -1) { sysErrorBelch("ioManagerDie: write"); }
 122         close(io_manager_pipe);
 123         io_manager_pipe = -1;
 124     }
 125 }
 126
 127 Capability *
 128 ioManagerStartCap (Capability *cap)
 129 {
 130     return rts_evalIO(cap,&base_GHCziConc_ensureIOManagerIsRunning_closure,NULL);
 131 }
 132
 133 void
 134 ioManagerStart (void)
 135 {
 136     // Make sure the IO manager thread is running
 137     Capability *cap;
 138     if (io_manager_pipe < 0) {
 139         cap = rts_lock();
 140         cap = ioManagerStartCap(cap);
 141         rts_unlock(cap);
 142     }
 143 }
 144 #endif
 145
 146 #if !defined(THREADED_RTS)
 147
 148 #define N_PENDING_HANDLERS 16
 149
 150 siginfo_t pending_handler_buf[N_PENDING_HANDLERS];
 151 siginfo_t *next_pending_handler = pending_handler_buf;
 152
 153 #endif /* THREADED_RTS */
 154
 155 /* -----------------------------------------------------------------------------
 156  * Low-level signal handler
 157  *
 158  * Places the requested handler on a stack of pending handlers to be
 159  * started up at the next context switch.
 160  * -------------------------------------------------------------------------- */
 161
 162 static void
 163 generic_handler(int sig USED_IF_THREADS,
 164                 siginfo_t *info,
 165                 void *p STG_UNUSED)
 166 {
 167 #if defined(THREADED_RTS)
 168
 169     if (io_manager_pipe != -1)
 170     {
 171         StgWord8 buf[sizeof(siginfo_t) + 1];
 172         int r;
 173
 174         buf[0] = sig;
 175         memcpy(buf+1, info, sizeof(siginfo_t));
 176         r = write(io_manager_pipe, buf, sizeof(siginfo_t)+1);
 177         if (r == -1 && errno == EAGAIN)
 178         {
 179             errorBelch("lost signal due to full pipe: %d\n", sig);
 180         }
 181     }
 182     // If the IO manager hasn't told us what the FD of the write end
 183     // of its pipe is, there's not much we can do here, so just ignore
 184     // the signal..
 185
 186 #else /* not THREADED_RTS */
 187
 188     /* Can't call allocate from here.  Probably can't call malloc
 189        either.  However, we have to schedule a new thread somehow.
 190
 191        It's probably ok to request a context switch and allow the
 192        scheduler to  start the handler thread, but how do we
 193        communicate this to the scheduler?
 194
 195        We need some kind of locking, but with low overhead (i.e. no
 196        blocking signals every time around the scheduler).
 197
 198        Signal Handlers are atomic (i.e. they can't be interrupted), and
 199        we can make use of this.  We just need to make sure the
 200        critical section of the scheduler can't be interrupted - the
 201        only way to do this is to block signals.  However, we can lower
 202        the overhead by only blocking signals when there are any
 203        handlers to run, i.e. the set of pending handlers is
 204        non-empty.
 205     */
 206
 207     /* We use a stack to store the pending signals.  We can't
 208        dynamically grow this since we can't allocate any memory from
 209        within a signal handler.
 210
 211        Hence unfortunately we have to bomb out if the buffer
 212        overflows.  It might be acceptable to carry on in certain
 213        circumstances, depending on the signal.
 214     */
 215
 216     memcpy(next_pending_handler, info, sizeof(siginfo_t));
 217
 218     next_pending_handler++;
 219
 220     // stack full?
 221     if (next_pending_handler == &pending_handler_buf[N_PENDING_HANDLERS]) {
 222         errorBelch("too many pending signals");
 223         stg_exit(EXIT_FAILURE);
 224     }
 225
 226     contextSwitchCapability(&MainCapability);
 227
 228 #endif /* THREADED_RTS */
 229 }
 230
 231 /* -----------------------------------------------------------------------------
 232  * Blocking/Unblocking of the user signals
 233  * -------------------------------------------------------------------------- */
 234
 235 static sigset_t userSignals;
 236 static sigset_t savedSignals;
 237
 238 void
 239 initUserSignals(void)
 240 {
 241     sigemptyset(&userSignals);
 242 #ifndef THREADED_RTS
 243     getStablePtr((StgPtr)&base_GHCziConc_runHandlers_closure);
 244     // needed to keep runHandler alive
 245 #endif
 246 }
 247
 248 void
 249 blockUserSignals(void)
 250 {
 251     sigprocmask(SIG_BLOCK, &userSignals, &savedSignals);
 252 }
 253
 254 void
 255 unblockUserSignals(void)
 256 {
 257     sigprocmask(SIG_SETMASK, &savedSignals, NULL);
 258 }
 259
 260 rtsBool
 261 anyUserHandlers(void)
 262 {
 263     return n_haskell_handlers != 0;
 264 }
 265
 266 #if !defined(THREADED_RTS)
 267 void
 268 awaitUserSignals(void)
 269 {
 270     while (!signals_pending() && sched_state == SCHED_RUNNING) {
 271         pause();
 272     }
 273 }
 274 #endif
 275
 276 /* -----------------------------------------------------------------------------
 277  * Install a Haskell signal handler.
 278  *
 279  * We should really do this in Haskell in GHC.Conc, and share the
 280  * signal_handlers array with the one there.
 281  *
 282  * -------------------------------------------------------------------------- */
 283
 284 int
 285 stg_sig_install(int sig, int spi, void *mask)
 286 {
 287     sigset_t signals, osignals;
 288     struct sigaction action;
 289     StgInt previous_spi;
 290
 291     // Block the signal until we figure out what to do
 292     // Count on this to fail if the signal number is invalid
 293     if (sig < 0 || sigemptyset(&signals) ||
 294         sigaddset(&signals, sig) || sigprocmask(SIG_BLOCK, &signals, &osignals)) {
 295         return STG_SIG_ERR;
 296     }
 297
 298     more_handlers(sig);
 299
 300     previous_spi = signal_handlers[sig];
 301
 302     action.sa_flags = 0;
 303
 304     switch(spi) {
 305     case STG_SIG_IGN:
 306         action.sa_handler = SIG_IGN;
 307         break;
 308
 309     case STG_SIG_DFL:
 310         action.sa_handler = SIG_DFL;
 311         break;
 312
 313     case STG_SIG_RST:
 314         action.sa_flags |= SA_RESETHAND;
 315         /* fall through */
 316     case STG_SIG_HAN:
 317         action.sa_sigaction = generic_handler;
 318         action.sa_flags |= SA_SIGINFO;
 319         break;
 320
 321     default:
 322         barf("stg_sig_install: bad spi");
 323     }
 324
 325     if (mask != NULL)
 326         action.sa_mask = *(sigset_t *)mask;
 327     else
 328         sigemptyset(&action.sa_mask);
 329
 330     action.sa_flags |= sig == SIGCHLD && nocldstop ? SA_NOCLDSTOP : 0;
 331
 332     if (sigaction(sig, &action, NULL))
 333     {
 334         errorBelch("sigaction");
 335         return STG_SIG_ERR;
 336     }
 337
 338     signal_handlers[sig] = spi;
 339
 340     switch(spi) {
 341     case STG_SIG_RST:
 342     case STG_SIG_HAN:
 343         sigaddset(&userSignals, sig);
 344         if (previous_spi != STG_SIG_HAN && previous_spi != STG_SIG_RST) {
 345             n_haskell_handlers++;
 346         }
 347         break;
 348
 349     default:
 350         sigdelset(&userSignals, sig);
 351         if (previous_spi == STG_SIG_HAN || previous_spi == STG_SIG_RST) {
 352             n_haskell_handlers--;
 353         }
 354         break;
 355     }
 356
 357     if (sigprocmask(SIG_SETMASK, &osignals, NULL))
 358     {
 359         errorBelch("sigprocmask");
 360         return STG_SIG_ERR;
 361     }
 362
 363     return previous_spi;
 364 }
 365
 366 /* -----------------------------------------------------------------------------
 367  * Creating new threads for signal handlers.
 368  * -------------------------------------------------------------------------- */
 369
 370 #if !defined(THREADED_RTS)
 371 void
 372 startSignalHandlers(Capability *cap)
 373 {
 374   siginfo_t *info;
 375   int sig;
 376
 377   blockUserSignals();
 378
 379   while (next_pending_handler != pending_handler_buf) {
 380
 381     next_pending_handler--;
 382
 383     sig = next_pending_handler->si_signo;
 384     if (signal_handlers[sig] == STG_SIG_DFL) {
 385         continue; // handler has been changed.
 386     }
 387
 388     info = stgMallocBytes(sizeof(siginfo_t), "startSignalHandlers");
 389            // freed by runHandler
 390     memcpy(info, next_pending_handler, sizeof(siginfo_t));
 391
 392     scheduleThread (cap,
 393         createIOThread(cap,
 394                        RtsFlags.GcFlags.initialStkSize,
 395                        rts_apply(cap,
 396                                  rts_apply(cap,
 397                                            &base_GHCziConc_runHandlers_closure,
 398                                            rts_mkPtr(cap, info)),
 399                                  rts_mkInt(cap, info->si_signo))));
 400   }
 401
 402   unblockUserSignals();
 403 }
 404 #endif
 405
 406 /* ----------------------------------------------------------------------------
 407  * Mark signal handlers during GC.
 408  * -------------------------------------------------------------------------- */
 409
 410 void
 411 markSignalHandlers (evac_fn evac STG_UNUSED, void *user STG_UNUSED)
 412 {
 413     // nothing to do
 414 }
 415
 416 #else /* !RTS_USER_SIGNALS */
 417 StgInt
 418 stg_sig_install(StgInt sig STG_UNUSED,
 419                 StgInt spi STG_UNUSED,
 420                 void* mask STG_UNUSED)
 421 {
 422   //barf("User signals not supported");
 423   return STG_SIG_DFL;
 424 }
 425
 426 #endif
 427
 428 #if defined(RTS_USER_SIGNALS)
 429 /* -----------------------------------------------------------------------------
 430  * SIGINT handler.
 431  *
 432  * We like to shutdown nicely after receiving a SIGINT, write out the
 433  * stats, write profiling info, close open files and flush buffers etc.
 434  * -------------------------------------------------------------------------- */
 435 static void
 436 shutdown_handler(int sig STG_UNUSED)
 437 {
 438     // If we're already trying to interrupt the RTS, terminate with
 439     // extreme prejudice.  So the first ^C tries to exit the program
 440     // cleanly, and the second one just kills it.
 441     if (sched_state >= SCHED_INTERRUPTING) {
 442         stg_exit(EXIT_INTERRUPTED);
 443     } else {
 444         interruptStgRts();
 445     }
 446 }
 447
 448 /* -----------------------------------------------------------------------------
 449  * Install default signal handlers.
 450  *
 451  * The RTS installs a default signal handler for catching
 452  * SIGINT, so that we can perform an orderly shutdown.
 453  *
 454  * Haskell code may install their own SIGINT handler, which is
 455  * fine, provided they're so kind as to put back the old one
 456  * when they de-install.
 457  *
 458  * In addition to handling SIGINT, the RTS also handles SIGFPE
 459  * by ignoring it.  Apparently IEEE requires floating-point
 460  * exceptions to be ignored by default, but alpha-dec-osf3
 461  * doesn't seem to do so.
 462  * -------------------------------------------------------------------------- */
 463 void
 464 initDefaultHandlers(void)
 465 {
 466     struct sigaction action,oact;
 467
 468     // install the SIGINT handler
 469     action.sa_handler = shutdown_handler;
 470     sigemptyset(&action.sa_mask);
 471     action.sa_flags = 0;
 472     if (sigaction(SIGINT, &action, &oact) != 0) {
 473         sysErrorBelch("warning: failed to install SIGINT handler");
 474     }
 475
 476 #if defined(HAVE_SIGINTERRUPT)
 477     siginterrupt(SIGINT, 1);    // isn't this the default? --SDM
 478 #endif
 479
 480     // install the SIGFPE handler
 481
 482     // In addition to handling SIGINT, also handle SIGFPE by ignoring it.
 483     // Apparently IEEE requires floating-point exceptions to be ignored by
 484     // default, but alpha-dec-osf3 doesn't seem to do so.
 485
 486     // Commented out by SDM 2/7/2002: this causes an infinite loop on
 487     // some architectures when an integer division by zero occurs: we
 488     // don't recover from the floating point exception, and the
 489     // program just generates another one immediately.
 490 #if 0
 491     action.sa_handler = SIG_IGN;
 492     sigemptyset(&action.sa_mask);
 493     action.sa_flags = 0;
 494     if (sigaction(SIGFPE, &action, &oact) != 0) {
 495         sysErrorBelch("warning: failed to install SIGFPE handler");
 496     }
 497 #endif
 498
 499 #ifdef alpha_HOST_ARCH
 500     ieee_set_fp_control(0);
 501 #endif
 502
 503     // ignore SIGPIPE; see #1619
 504     action.sa_handler = SIG_IGN;
 505     sigemptyset(&action.sa_mask);
 506     action.sa_flags = 0;
 507     if (sigaction(SIGPIPE, &action, &oact) != 0) {
 508         sysErrorBelch("warning: failed to install SIGPIPE handler");
 509     }
 510 }
 511
 512 void
 513 resetDefaultHandlers(void)
 514 {
 515     struct sigaction action;
 516
 517     action.sa_handler = SIG_DFL;
 518     sigemptyset(&action.sa_mask);
 519     action.sa_flags = 0;
 520
 521     // restore SIGINT
 522     if (sigaction(SIGINT, &action, NULL) != 0) {
 523         sysErrorBelch("warning: failed to uninstall SIGINT handler");
 524     }
 525     // restore SIGPIPE
 526     if (sigaction(SIGPIPE, &action, NULL) != 0) {
 527         sysErrorBelch("warning: failed to uninstall SIGPIPE handler");
 528     }
 529 }
 530
 531 void
 532 freeSignalHandlers(void) {
 533     if (signal_handlers != NULL) {
 534         stgFree(signal_handlers);
 535     }
 536 }
 537
 538 #endif /* RTS_USER_SIGNALS */