Adjust for __pthread_lock interface change. Use already computed self
[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, 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 }