|
0
|
1 /* syssignal.h - System-dependent definitions for signals.
|
|
|
2 Copyright (C) 1992, 1993 Free Software Foundation, Inc.
|
|
|
3
|
|
|
4 This file is part of XEmacs.
|
|
|
5
|
|
|
6 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
7 under the terms of the GNU General Public License as published by the
|
|
|
8 Free Software Foundation; either version 2, or (at your option) any
|
|
|
9 later version.
|
|
|
10
|
|
|
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
14 for more details.
|
|
|
15
|
|
|
16 You should have received a copy of the GNU General Public License
|
|
|
17 along with XEmacs; see the file COPYING. If not, write to
|
|
|
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
19 Boston, MA 02111-1307, USA. */
|
|
|
20
|
|
|
21 /* Synched up with: FSF 19.30. */
|
|
|
22
|
|
|
23 #ifndef _XEMACS_SYSSIGNAL_H_
|
|
|
24 #define _XEMACS_SYSSIGNAL_H_
|
|
|
25
|
|
|
26 /* In the old world, one could not #include <signal.h> here. The party line
|
|
|
27 was that that header should always be #included before <config.h>, because
|
|
|
28 some configuration files (like s/hpux.h) indicate that SIGIO doesn't work
|
|
|
29 by #undef-ing SIGIO, and if this file #includes <signal.h>, then that will
|
|
|
30 re-#define SIGIO and confuse things.
|
|
|
31
|
|
|
32 This was, however, a completely fucked up state of affairs, because on some
|
|
|
33 systems it's necessary for the s/m files to #define things in order to get
|
|
|
34 <signal.h> to provide the right typedefs, etc. And it's generally a broken
|
|
|
35 concept for <config.h> to not be the very very first file included.
|
|
|
36
|
|
|
37 So instead of #undef'ing SIGIO in the various s/m files, I've changed them
|
|
|
38 to define BROKEN_SIGIO instead, then we (syssignal.h) do an #undef SIGIO
|
|
|
39 at the end, after including signal.h. Therefore, it's important that
|
|
|
40 <signal.h> not be included after "syssignal.h", but that's the normal state:
|
|
|
41 nothing should be directly including <signal.h> these days.
|
|
|
42 -- jwz, 29-nov-93
|
|
|
43 */
|
|
|
44
|
|
|
45 #include <signal.h>
|
|
|
46 #include <errno.h>
|
|
|
47
|
|
|
48 /* SIGPOLL is the SVR4 signal. Those systems generally define
|
|
|
49 SIGIO as an alias for SIGPOLL, but just in case ... */
|
|
|
50
|
|
|
51 #if !defined (SIGIO) && defined (SIGPOLL)
|
|
|
52 # define SIGIO SIGPOLL
|
|
|
53 #endif
|
|
|
54
|
|
|
55 #if defined (BROKEN_SIGIO)
|
|
|
56 # undef SIGIO
|
|
|
57 #endif
|
|
|
58
|
|
|
59 /* Define SIGCHLD as an alias for SIGCLD. There are many conditionals
|
|
|
60 testing SIGCHLD. */
|
|
|
61 #if !defined (VMS) && defined (SIGCLD) && !defined (SIGCHLD)
|
|
|
62 # define SIGCHLD SIGCLD
|
|
|
63 #endif /* SIGCHLD */
|
|
|
64
|
|
|
65 #ifdef BROKEN_SIGCHLD
|
|
|
66 #undef SIGCHLD
|
|
|
67 #endif
|
|
|
68
|
|
|
69 #ifdef SIGCHLD
|
|
|
70 #define EMACS_BLOCK_SIGCHLD EMACS_BLOCK_SIGNAL (SIGCHLD)
|
|
|
71 #define EMACS_UNBLOCK_SIGCHLD EMACS_UNBLOCK_SIGNAL (SIGCHLD)
|
|
|
72 #else
|
|
|
73 #define EMACS_BLOCK_SIGCHLD
|
|
|
74 #define EMACS_UNBLOCK_SIGCHLD
|
|
|
75 #endif
|
|
|
76
|
|
|
77 /* According to W.R. Stevens __Advanced Programming in the Unix
|
|
|
78 Environment__, there are four different paradigms for handling
|
|
|
79 signals. We use autoconf to tell us which one applies.
|
|
|
80
|
|
|
81 Note that on some systems, more than one paradigm is implemented
|
|
|
82 (typically, the POSIX sigaction/sigprocmask and either the older
|
|
|
83 SYSV or BSD way). In such a case, we prefer the POSIX way.
|
|
|
84
|
|
|
85 NOTE: We use EMACS_* macros for most signal operations, but
|
|
|
86 just signal() for the standard signal-setting operation.
|
|
|
87 Perhaps we should change this to EMACS_SIGNAL(), but that runs
|
|
|
88 the risk of someone forgetting this convention and calling
|
|
|
89 signal() directly. */
|
|
|
90
|
|
12
|
91 #ifndef NeXT
|
|
8
|
92 typedef SIGTYPE (*signal_handler_t) (int);
|
|
12
|
93 #endif
|
|
8
|
94
|
|
0
|
95 #if defined (HAVE_SIGPROCMASK)
|
|
|
96
|
|
|
97 /* The POSIX way (sigaction, sigprocmask, sigpending, sigsuspend) */
|
|
|
98
|
|
|
99 extern signal_handler_t sys_do_signal (int signal_number,
|
|
|
100 signal_handler_t action);
|
|
|
101 /* Provide our own version of signal(), that calls sigaction(). The
|
|
|
102 name is not sys_signal() because a function of that name exists in
|
|
|
103 libenergize.a */
|
|
|
104 #undef signal
|
|
|
105 #define signal sys_do_signal
|
|
|
106
|
|
|
107 #define EMACS_BLOCK_SIGNAL(sig) do \
|
|
|
108 { \
|
|
|
109 sigset_t _mask; \
|
|
|
110 sigemptyset (&_mask); \
|
|
|
111 sigaddset (&_mask, sig); \
|
|
|
112 sigprocmask (SIG_BLOCK, &_mask, NULL); \
|
|
|
113 } while (0)
|
|
|
114 #define EMACS_UNBLOCK_SIGNAL(sig) do \
|
|
|
115 { \
|
|
|
116 sigset_t _mask; \
|
|
|
117 sigemptyset (&_mask); \
|
|
|
118 sigaddset (&_mask, sig); \
|
|
|
119 sigprocmask (SIG_UNBLOCK, &_mask, NULL); \
|
|
|
120 } while (0)
|
|
|
121 #define EMACS_UNBLOCK_ALL_SIGNALS() do \
|
|
|
122 { \
|
|
|
123 sigset_t _mask; \
|
|
|
124 sigemptyset (&_mask); \
|
|
|
125 sigprocmask (SIG_SETMASK, &_mask, NULL); \
|
|
|
126 } while (0)
|
|
|
127 #define EMACS_WAIT_FOR_SIGNAL(sig) do \
|
|
|
128 { \
|
|
|
129 sigset_t _mask; \
|
|
|
130 sigprocmask (0, NULL, &_mask); \
|
|
|
131 sigdelset (&_mask, sig); \
|
|
|
132 sigsuspend (&_mask); \
|
|
|
133 } while (0)
|
|
|
134 #define EMACS_REESTABLISH_SIGNAL(sig, handler)
|
|
|
135
|
|
|
136 #elif defined (HAVE_SIGBLOCK)
|
|
|
137
|
|
|
138 /* The older BSD way (signal/sigvec, sigblock, sigsetmask, sigpause) */
|
|
|
139
|
|
|
140 /* It's OK to use signal() here directly. No unreliable signal
|
|
|
141 problems. However, we use sigvec() because it allows us to
|
|
|
142 request interruptible I/O. */
|
|
|
143
|
|
|
144 #define signal sys_do_signal
|
|
|
145
|
|
|
146 /* Is it necessary to define sigmask like this? */
|
|
|
147 #ifndef sigmask
|
|
|
148 # define sigmask(no) (1L << ((no) - 1))
|
|
|
149 #endif
|
|
|
150
|
|
|
151 #define EMACS_BLOCK_SIGNAL(sig) sigblock (sigmask (sig))
|
|
|
152 #define EMACS_UNBLOCK_SIGNAL(sig) sigsetmask (sigblock (0) & ~sigmask (sig))
|
|
|
153 #define EMACS_UNBLOCK_ALL_SIGNALS() sigsetmask (0)
|
|
|
154 #define EMACS_WAIT_FOR_SIGNAL(sig) do \
|
|
|
155 { \
|
|
|
156 int _mask = sigblock (0); \
|
|
|
157 sigpause (_mask & ~sigmask (sig)); \
|
|
|
158 } while (0)
|
|
|
159 #define EMACS_REESTABLISH_SIGNAL(sig, handler)
|
|
|
160
|
|
|
161 #elif defined (HAVE_SIGHOLD)
|
|
|
162
|
|
|
163 /* The older SYSV way (signal/sigset, sighold, sigrelse, sigignore,
|
|
|
164 sigpause) */
|
|
|
165
|
|
|
166 #define signal sigset
|
|
|
167 #define EMACS_BLOCK_SIGNAL(sig) sighold (sig)
|
|
|
168 #define EMACS_UNBLOCK_SIGNAL(sig) sigrelse (sig)
|
|
|
169 /* #### There's not really any simple way to implement this.
|
|
|
170 Since EMACS_UNBLOCK_ALL_SIGNALS() is only called once (at startup),
|
|
|
171 it's probably OK to just ignore it. */
|
|
|
172 #define EMACS_UNBLOCK_ALL_SIGNALS() 0
|
|
|
173 #define EMACS_WAIT_FOR_SIGNAL(sig) sigpause (sig)
|
|
|
174 #define EMACS_REESTABLISH_SIGNAL(sig, handler)
|
|
|
175
|
|
|
176 #else
|
|
|
177
|
|
|
178 /* The oldest SYSV way (signal only; unreliable signals) */
|
|
|
179
|
|
|
180 /* Old USG systems don't really have signal blocking.
|
|
|
181 We indicate this by not defining EMACS_BLOCK_SIGNAL or
|
|
|
182 EMACS_WAIT_FOR_SIGNAL. */
|
|
|
183 #define EMACS_UNBLOCK_SIGNAL(sig) 0
|
|
|
184 #define EMACS_UNBLOCK_ALL_SIGNALS() 0
|
|
|
185 #define EMACS_REESTABLISH_SIGNAL(sig, handler) do \
|
|
|
186 { \
|
|
|
187 int old_errno = errno; \
|
|
|
188 signal (sig, handler); \
|
|
|
189 errno = old_errno; \
|
|
|
190 } while (0)
|
|
|
191
|
|
|
192 /* Under SYSV, setting a signal handler for SIGCLD causes
|
|
|
193 SIGCLD to immediately be sent if there any unwaited processes
|
|
|
194 out there. This means that the SIGCLD handler *must* call
|
|
|
195 wait() to reap the status of all processes -- it cannot
|
|
|
196 simply set a flag and then reestablish the handler, because
|
|
|
197 it will get called again, infinitely. We only need to
|
|
|
198 worry about this on systems where signals need to be
|
|
|
199 reestablished (SYSV Release 2 and earlier). */
|
|
|
200 #define OBNOXIOUS_SYSV_SIGCLD_BEHAVIOR
|
|
|
201
|
|
|
202 #endif
|
|
|
203
|
|
|
204 /* On bsd, [man says] kill does not accept a negative number to kill a pgrp.
|
|
|
205 Must do that using the killpg call. */
|
|
|
206 #ifdef BSD
|
|
|
207 #define EMACS_KILLPG(gid, signo) killpg (gid, signo)
|
|
|
208 #else
|
|
|
209 #ifdef WINDOWSNT
|
|
|
210 #define EMACS_KILLPG(gid, signo) (win32_kill_process (gid, signo))
|
|
|
211 #else
|
|
|
212 #define EMACS_KILLPG(gid, signo) kill (-(gid), signo)
|
|
|
213 #endif
|
|
|
214 #endif
|
|
|
215
|
|
|
216 #ifdef VMS
|
|
|
217 # define sys_siglist sys_errlist
|
|
|
218 # define NSIG sys_nerr
|
|
|
219 #endif /* VMS */
|
|
|
220
|
|
|
221 #ifndef NSIG
|
|
|
222 # define NSIG (SIGUSR2+1) /* guess how many elements are in sys_siglist... */
|
|
|
223 #endif
|
|
|
224
|
|
|
225 /* SYS_SIGLIST_DECLARED is determined by configure. On Linux, it seems,
|
|
|
226 configure incorrectly fails to find it, so s/linux.h defines
|
|
|
227 HAVE_SYS_SIGLIST. */
|
|
|
228 #if !defined (SYS_SIGLIST_DECLARED) && !defined (HAVE_SYS_SIGLIST)
|
|
|
229 extern CONST char *sys_siglist[];
|
|
|
230 #endif
|
|
|
231
|
|
|
232 #ifdef SIGDANGER
|
|
|
233 extern SIGTYPE memory_warning_signal (int sig);
|
|
|
234 #endif
|
|
|
235
|
|
|
236 #endif /* _XEMACS_SYSSIGNAL_H_ */
|
