linuxthreads/signals.c

   1 /* Linuxthreads - a simple clone()-based implementation of Posix        */
   2 /* threads for Linux.                                                   */
   3 /* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr)              */
   4 /*                                                                      */
   5 /* This program is free software; you can redistribute it and/or        */
   6 /* modify it under the terms of the GNU Library General Public License  */
   7 /* as published by the Free Software Foundation; either version 2       */
   8 /* of the License, or (at your option) any later version.               */
   9 /*                                                                      */
  10 /* This program is distributed in the hope that it will be useful,      */
  11 /* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
  12 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
  13 /* GNU Library General Public License for more details.                 */
  14
  15 /* Handling of signals */
  16
  17 #include <errno.h>
  18 #include <signal.h>
  19 #include "pthread.h"
  20 #include "internals.h"
  21 #include "spinlock.h"
  22
  23 int pthread_sigmask(int how, const sigset_t * newmask, sigset_t * oldmask)
  24 {
  25   sigset_t mask;
  26
  27   if (newmask != NULL) {
  28     mask = *newmask;
  29     /* Don't allow __pthread_sig_restart to be unmasked.
  30        Don't allow __pthread_sig_cancel to be masked. */
  31     switch(how) {
  32     case SIG_SETMASK:
  33       sigaddset(&mask, __pthread_sig_restart);
  34       sigdelset(&mask, __pthread_sig_cancel);
  35       break;
  36     case SIG_BLOCK:
  37       sigdelset(&mask, __pthread_sig_cancel);
  38       break;
  39     case SIG_UNBLOCK:
  40       sigdelset(&mask, __pthread_sig_restart);
  41       break;
  42     }
  43     newmask = &mask;
  44   }
  45   if (sigprocmask(how, newmask, oldmask) == -1)
  46     return errno;
  47   else
  48     return 0;
  49 }
  50
  51 int pthread_kill(pthread_t thread, int signo)
  52 {
  53   pthread_handle handle = thread_handle(thread);
  54   int pid;
  55
  56   __pthread_lock(&handle->h_lock, NULL);
  57   if (invalid_handle(handle, thread)) {
  58     __pthread_unlock(&handle->h_lock);
  59     return ESRCH;
  60   }
  61   pid = handle->h_descr->p_pid;
  62   __pthread_unlock(&handle->h_lock);
  63   if (kill(pid, signo) == -1)
  64     return errno;
  65   else
  66     return 0;
  67 }
  68
  69 /* User-provided signal handlers */
  70 static __sighandler_t sighandler[NSIG];
  71
  72 /* The wrapper around user-provided signal handlers */
  73 static void pthread_sighandler(int signo)
  74 {
  75   pthread_descr self = thread_self();
  76   char * in_sighandler;
  77   /* If we're in a sigwait operation, just record the signal received
  78      and return without calling the user's handler */
  79   if (THREAD_GETMEM(self, p_sigwaiting)) {
  80     THREAD_SETMEM(self, p_sigwaiting, 0);
  81     THREAD_SETMEM(self, p_signal, signo);
  82     return;
  83   }
  84   /* Record that we're in a signal handler and call the user's
  85      handler function */
  86   in_sighandler = THREAD_GETMEM(self, p_in_sighandler);
  87   if (in_sighandler == NULL)
  88     THREAD_SETMEM(self, p_in_sighandler, CURRENT_STACK_FRAME);
  89   sighandler[signo](signo);
  90   if (in_sighandler == NULL)
  91     THREAD_SETMEM(self, p_in_sighandler, NULL);
  92 }
  93
  94 int sigaction(int sig, const struct sigaction * act,
  95               struct sigaction * oact)
  96 {
  97   struct sigaction newact;
  98   struct sigaction *newactp;
  99
 100   if (sig == __pthread_sig_restart || sig == __pthread_sig_cancel)
 101     return EINVAL;
 102   if (act)
 103     {
 104       newact = *act;
 105       if (act->sa_handler != SIG_IGN && act->sa_handler != SIG_DFL
 106           && sig < NSIG)
 107         newact.sa_handler = pthread_sighandler;
 108       newactp = &newact;
 109     }
 110   else
 111     newactp = NULL;
 112   if (__sigaction(sig, newactp, oact) == -1)
 113     return -1;
 114   if (sig < NSIG)
 115     {
 116       if (oact != NULL)
 117         oact->sa_handler = sighandler[sig];
 118       if (act)
 119         sighandler[sig] = act->sa_handler;
 120     }
 121   return 0;
 122 }
 123
 124 int sigwait(const sigset_t * set, int * sig)
 125 {
 126   volatile pthread_descr self = thread_self();
 127   sigset_t mask;
 128   int s;
 129   sigjmp_buf jmpbuf;
 130
 131   /* Get ready to block all signals except those in set
 132      and the cancellation signal */
 133   sigfillset(&mask);
 134   sigdelset(&mask, __pthread_sig_cancel);
 135   for (s = 1; s <= NSIG; s++) {
 136     if (sigismember(set, s) && s != __pthread_sig_cancel)
 137       sigdelset(&mask, s);
 138   }
 139   /* Test for cancellation */
 140   if (sigsetjmp(jmpbuf, 1) == 0) {
 141     THREAD_SETMEM(self, p_cancel_jmp, &jmpbuf);
 142     if (! (THREAD_GETMEM(self, p_canceled)
 143            && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE)) {
 144       /* Reset the signal count */
 145       THREAD_SETMEM(self, p_signal, 0);
 146       /* Say we're in sigwait */
 147       THREAD_SETMEM(self, p_sigwaiting, 1);
 148       /* Unblock the signals and wait for them */
 149       sigsuspend(&mask);
 150     }
 151   }
 152   THREAD_SETMEM(self, p_cancel_jmp, NULL);
 153   /* The signals are now reblocked.  Check for cancellation */
 154   pthread_testcancel();
 155   /* We should have self->p_signal != 0 and equal to the signal received */
 156   *sig = THREAD_GETMEM(self, p_signal);
 157   return 0;
 158 }
 159
 160 int raise (int sig)
 161 {
 162   int retcode = pthread_kill(pthread_self(), sig);
 163   if (retcode == 0)
 164     return 0;
 165   else {
 166     errno = retcode;
 167     return -1;
 168   }
 169 }