Use __pthread_sig_cancel and __pthread_sig_restart everywhere instead
[kopensolaris-gnu/glibc.git] / 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);
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 (self->p_sigwaiting) {
80     self->p_sigwaiting = 0;
81     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 = self->p_in_sighandler;
87   if (in_sighandler == NULL) self->p_in_sighandler = CURRENT_STACK_FRAME;
88   sighandler[signo](signo);
89   if (in_sighandler == NULL) self->p_in_sighandler = NULL;
90 }
91
92 int sigaction(int sig, const struct sigaction * act,
93               struct sigaction * oact)
94 {
95   struct sigaction newact;
96
97   if (sig == __pthread_sig_restart || sig == __pthread_sig_cancel)
98     return EINVAL;
99   newact = *act;
100   if (act->sa_handler != SIG_IGN && act->sa_handler != SIG_DFL)
101     newact.sa_handler = pthread_sighandler;
102   if (__sigaction(sig, &newact, oact) == -1)
103     return -1;
104   if (oact != NULL) oact->sa_handler = sighandler[sig];
105   sighandler[sig] = act->sa_handler;
106   return 0;
107 }
108
109 int sigwait(const sigset_t * set, int * sig)
110 {
111   volatile pthread_descr self = thread_self();
112   sigset_t mask;
113   int s;
114   sigjmp_buf jmpbuf;
115
116   /* Get ready to block all signals except those in set
117      and the cancellation signal */
118   sigfillset(&mask);
119   sigdelset(&mask, __pthread_sig_cancel);
120   for (s = 1; s <= NSIG; s++) {
121     if (sigismember(set, s) && s != __pthread_sig_cancel)
122       sigdelset(&mask, s);
123   }
124   /* Test for cancellation */
125   if (sigsetjmp(jmpbuf, 1) == 0) {
126     self->p_cancel_jmp = &jmpbuf;
127     if (! (self->p_canceled && self->p_cancelstate == PTHREAD_CANCEL_ENABLE)) {
128       /* Reset the signal count */
129       self->p_signal = 0;
130       /* Say we're in sigwait */
131       self->p_sigwaiting = 1;
132       /* Unblock the signals and wait for them */
133       sigsuspend(&mask);
134     }
135   }
136   self->p_cancel_jmp = NULL;
137   /* The signals are now reblocked.  Check for cancellation */
138   pthread_testcancel();
139   /* We should have self->p_signal != 0 and equal to the signal received */
140   *sig = self->p_signal;
141   return 0;
142 }
143
144 int raise (int sig)
145 {
146   int retcode = pthread_kill(pthread_self(), sig);
147   if (retcode == 0)
148     return 0;
149   else {
150     errno = retcode;
151     return -1;
152   }
153 }