2002-07-20 Han-Wen <hanwen@cs.uu.nl>
[bpt/guile.git] / libguile / scmsigs.c
1 /* Copyright (C) 1995,1996,1997,1998,1999,2000,2001 Free Software Foundation, Inc.
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2, or (at your option)
6 * any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this software; see the file COPYING. If not, write to
15 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
16 * Boston, MA 02111-1307 USA
17 *
18 * As a special exception, the Free Software Foundation gives permission
19 * for additional uses of the text contained in its release of GUILE.
20 *
21 * The exception is that, if you link the GUILE library with other files
22 * to produce an executable, this does not by itself cause the
23 * resulting executable to be covered by the GNU General Public License.
24 * Your use of that executable is in no way restricted on account of
25 * linking the GUILE library code into it.
26 *
27 * This exception does not however invalidate any other reasons why
28 * the executable file might be covered by the GNU General Public License.
29 *
30 * This exception applies only to the code released by the
31 * Free Software Foundation under the name GUILE. If you copy
32 * code from other Free Software Foundation releases into a copy of
33 * GUILE, as the General Public License permits, the exception does
34 * not apply to the code that you add in this way. To avoid misleading
35 * anyone as to the status of such modified files, you must delete
36 * this exception notice from them.
37 *
38 * If you write modifications of your own for GUILE, it is your choice
39 * whether to permit this exception to apply to your modifications.
40 * If you do not wish that, delete this exception notice. */
41
42
43 \f
44
45 #include <signal.h>
46 #include <errno.h>
47
48 #include "libguile/_scm.h"
49
50 #include "libguile/async.h"
51 #include "libguile/eval.h"
52 #include "libguile/root.h"
53 #include "libguile/vectors.h"
54
55 #include "libguile/validate.h"
56 #include "libguile/scmsigs.h"
57
58 #ifdef HAVE_UNISTD_H
59 #include <unistd.h>
60 #endif
61
62 #ifdef HAVE_SYS_TIME_H
63 #include <sys/time.h>
64 #endif
65
66 /* The thread system has its own sleep and usleep functions. */
67 #ifndef USE_THREADS
68
69 #if defined(MISSING_SLEEP_DECL)
70 int sleep ();
71 #endif
72
73 #if defined(HAVE_USLEEP) && defined(MISSING_USLEEP_DECL)
74 int usleep ();
75 #endif
76
77 #endif
78
79 #ifdef __MINGW32__
80 #include <windows.h>
81 #define alarm(sec) (0)
82 /* This weird comma expression is because Sleep is void under Windows. */
83 #define sleep(sec) (Sleep ((sec) * 1000), 0)
84 #define usleep(usec) (Sleep ((usec) / 1000), 0)
85 #define kill(pid, sig) raise (sig)
86 #endif
87
88 \f
89
90 /* SIGRETTYPE is the type that signal handlers return. See <signal.h> */
91
92 #ifdef RETSIGTYPE
93 # define SIGRETTYPE RETSIGTYPE
94 #else
95 # ifdef STDC_HEADERS
96 # define SIGRETTYPE void
97 # else
98 # define SIGRETTYPE int
99 # endif
100 #endif
101
102 \f
103
104 /* take_signal is installed as the C signal handler whenever a Scheme
105 handler is set. when a signal arrives, take_signal marks the corresponding
106 element of got_signal and marks signal_async. the thunk in signal_async
107 (sys_deliver_signals) will be run at the next opportunity, outside a
108 critical section. sys_deliver_signals runs each Scheme handler for
109 which got_signal is set. */
110
111 static SCM signal_async;
112
113 static char got_signal[NSIG];
114
115 /* a Scheme vector of handler procedures. */
116 static SCM *signal_handlers;
117
118 /* saves the original C handlers, when a new handler is installed.
119 set to SIG_ERR if the original handler is installed. */
120 #ifdef HAVE_SIGACTION
121 static struct sigaction orig_handlers[NSIG];
122 #else
123 static SIGRETTYPE (*orig_handlers[NSIG])(int);
124 #endif
125
126 static SIGRETTYPE
127 take_signal (int signum)
128 {
129 got_signal[signum] = 1;
130 scm_system_async_mark_from_signal_handler (signal_async);
131 }
132
133 static SCM
134 sys_deliver_signals (void)
135 {
136 int i;
137
138 for (i = 0; i < NSIG; i++)
139 {
140 if (got_signal[i])
141 {
142 /* The flag is reset before calling the handler in case the
143 handler doesn't return. If the handler doesn't return
144 but leaves other signals flagged, they their handlers
145 will be applied some time later when the async is checked
146 again. It would probably be better to reset the flags
147 after doing a longjmp. */
148 got_signal[i] = 0;
149 #ifndef HAVE_SIGACTION
150 signal (i, take_signal);
151 #endif
152 scm_call_1 (SCM_VELTS (*signal_handlers)[i], SCM_MAKINUM (i));
153 }
154 }
155 return SCM_UNSPECIFIED;
156 }
157
158 /* user interface for installation of signal handlers. */
159 SCM_DEFINE (scm_sigaction, "sigaction", 1, 2, 0,
160 (SCM signum, SCM handler, SCM flags),
161 "Install or report the signal handler for a specified signal.\n\n"
162 "@var{signum} is the signal number, which can be specified using the value\n"
163 "of variables such as @code{SIGINT}.\n\n"
164 "If @var{action} is omitted, @code{sigaction} returns a pair: the\n"
165 "CAR is the current\n"
166 "signal hander, which will be either an integer with the value @code{SIG_DFL}\n"
167 "(default action) or @code{SIG_IGN} (ignore), or the Scheme procedure which\n"
168 "handles the signal, or @code{#f} if a non-Scheme procedure handles the\n"
169 "signal. The CDR contains the current @code{sigaction} flags for the handler.\n\n"
170 "If @var{action} is provided, it is installed as the new handler for\n"
171 "@var{signum}. @var{action} can be a Scheme procedure taking one\n"
172 "argument, or the value of @code{SIG_DFL} (default action) or\n"
173 "@code{SIG_IGN} (ignore), or @code{#f} to restore whatever signal handler\n"
174 "was installed before @code{sigaction} was first used. Flags can\n"
175 "optionally be specified for the new handler (@code{SA_RESTART} will\n"
176 "always be added if it's available and the system is using restartable\n"
177 "system calls.) The return value is a pair with information about the\n"
178 "old handler as described above.\n\n"
179 "This interface does not provide access to the \"signal blocking\"\n"
180 "facility. Maybe this is not needed, since the thread support may\n"
181 "provide solutions to the problem of consistent access to data\n"
182 "structures.")
183 #define FUNC_NAME s_scm_sigaction
184 {
185 int csig;
186 #ifdef HAVE_SIGACTION
187 struct sigaction action;
188 struct sigaction old_action;
189 #else
190 SIGRETTYPE (* chandler) (int) = SIG_DFL;
191 SIGRETTYPE (* old_chandler) (int);
192 #endif
193 int query_only = 0;
194 int save_handler = 0;
195
196 SCM old_handler;
197
198 SCM_VALIDATE_INUM_COPY (1, signum, csig);
199 #if defined(HAVE_SIGACTION)
200 #if defined(SA_RESTART) && defined(HAVE_RESTARTABLE_SYSCALLS)
201 /* don't allow SA_RESTART to be omitted if HAVE_RESTARTABLE_SYSCALLS
202 is defined, since libguile would be likely to produce spurious
203 EINTR errors. */
204 action.sa_flags = SA_RESTART;
205 #else
206 action.sa_flags = 0;
207 #endif
208 if (!SCM_UNBNDP (flags))
209 {
210 SCM_VALIDATE_INUM (3, flags);
211 action.sa_flags |= SCM_INUM (flags);
212 }
213 sigemptyset (&action.sa_mask);
214 #endif
215 SCM_DEFER_INTS;
216 old_handler = SCM_VELTS(*signal_handlers)[csig];
217 if (SCM_UNBNDP (handler))
218 query_only = 1;
219 else if (SCM_EQ_P (scm_integer_p (handler), SCM_BOOL_T))
220 {
221 if (SCM_NUM2LONG (2, handler) == (long) SIG_DFL
222 || SCM_NUM2LONG (2, handler) == (long) SIG_IGN)
223 {
224 #ifdef HAVE_SIGACTION
225 action.sa_handler = (SIGRETTYPE (*) (int)) SCM_INUM (handler);
226 #else
227 chandler = (SIGRETTYPE (*) (int)) SCM_INUM (handler);
228 #endif
229 SCM_VECTOR_SET (*signal_handlers, csig, SCM_BOOL_F);
230 }
231 else
232 SCM_OUT_OF_RANGE (2, handler);
233 }
234 else if (SCM_FALSEP (handler))
235 {
236 /* restore the default handler. */
237 #ifdef HAVE_SIGACTION
238 if (orig_handlers[csig].sa_handler == SIG_ERR)
239 query_only = 1;
240 else
241 {
242 action = orig_handlers[csig];
243 orig_handlers[csig].sa_handler = SIG_ERR;
244 SCM_VECTOR_SET (*signal_handlers, csig, SCM_BOOL_F);
245
246 }
247 #else
248 if (orig_handlers[csig] == SIG_ERR)
249 query_only = 1;
250 else
251 {
252 chandler = orig_handlers[csig];
253 orig_handlers[csig] = SIG_ERR;
254 SCM_VECTOR_SET (*signal_handlers, csig, SCM_BOOL_F);
255 }
256 #endif
257 }
258 else
259 {
260 SCM_VALIDATE_NIM (2, handler);
261 #ifdef HAVE_SIGACTION
262 action.sa_handler = take_signal;
263 if (orig_handlers[csig].sa_handler == SIG_ERR)
264 save_handler = 1;
265 #else
266 chandler = take_signal;
267 if (orig_handlers[csig] == SIG_ERR)
268 save_handler = 1;
269 #endif
270 SCM_VECTOR_SET (*signal_handlers, csig, handler);
271 }
272
273 /* XXX - Silently ignore setting handlers for `program error signals'
274 because they can't currently be handled by Scheme code.
275 */
276
277 switch (csig)
278 {
279 /* This list of program error signals is from the GNU Libc
280 Reference Manual */
281 case SIGFPE:
282 case SIGILL:
283 case SIGSEGV:
284 #ifdef SIGBUS
285 case SIGBUS:
286 #endif
287 case SIGABRT:
288 #if defined(SIGIOT) && (SIGIOT != SIGABRT)
289 case SIGIOT:
290 #endif
291 #ifdef SIGTRAP
292 case SIGTRAP:
293 #endif
294 #ifdef SIGEMT
295 case SIGEMT:
296 #endif
297 #ifdef SIGSYS
298 case SIGSYS:
299 #endif
300 query_only = 1;
301 }
302
303 #ifdef HAVE_SIGACTION
304 if (query_only)
305 {
306 if (sigaction (csig, 0, &old_action) == -1)
307 SCM_SYSERROR;
308 }
309 else
310 {
311 if (sigaction (csig, &action , &old_action) == -1)
312 SCM_SYSERROR;
313 if (save_handler)
314 orig_handlers[csig] = old_action;
315 }
316 if (old_action.sa_handler == SIG_DFL || old_action.sa_handler == SIG_IGN)
317 old_handler = scm_long2num ((long) old_action.sa_handler);
318 SCM_ALLOW_INTS;
319 return scm_cons (old_handler, SCM_MAKINUM (old_action.sa_flags));
320 #else
321 if (query_only)
322 {
323 if ((old_chandler = signal (csig, SIG_IGN)) == SIG_ERR)
324 SCM_SYSERROR;
325 if (signal (csig, old_chandler) == SIG_ERR)
326 SCM_SYSERROR;
327 }
328 else
329 {
330 if ((old_chandler = signal (csig, chandler)) == SIG_ERR)
331 SCM_SYSERROR;
332 if (save_handler)
333 orig_handlers[csig] = old_chandler;
334 }
335 if (old_chandler == SIG_DFL || old_chandler == SIG_IGN)
336 old_handler = scm_long2num ((long) old_chandler);
337 SCM_ALLOW_INTS;
338 return scm_cons (old_handler, SCM_MAKINUM (0));
339 #endif
340 }
341 #undef FUNC_NAME
342
343 SCM_DEFINE (scm_restore_signals, "restore-signals", 0, 0, 0,
344 (void),
345 "Return all signal handlers to the values they had before any call to\n"
346 "@code{sigaction} was made. The return value is unspecified.")
347 #define FUNC_NAME s_scm_restore_signals
348 {
349 int i;
350 for (i = 0; i < NSIG; i++)
351 {
352 #ifdef HAVE_SIGACTION
353 if (orig_handlers[i].sa_handler != SIG_ERR)
354 {
355 if (sigaction (i, &orig_handlers[i], NULL) == -1)
356 SCM_SYSERROR;
357 orig_handlers[i].sa_handler = SIG_ERR;
358 SCM_VECTOR_SET (*signal_handlers, i, SCM_BOOL_F);
359 }
360 #else
361 if (orig_handlers[i] != SIG_ERR)
362 {
363 if (signal (i, orig_handlers[i]) == SIG_ERR)
364 SCM_SYSERROR;
365 orig_handlers[i] = SIG_ERR;
366 SCM_VECTOR_SET (*signal_handlers, i, SCM_BOOL_F);
367 }
368 #endif
369 }
370 return SCM_UNSPECIFIED;
371 }
372 #undef FUNC_NAME
373
374 SCM_DEFINE (scm_alarm, "alarm", 1, 0, 0,
375 (SCM i),
376 "Set a timer to raise a @code{SIGALRM} signal after the specified\n"
377 "number of seconds (an integer). It's advisable to install a signal\n"
378 "handler for\n"
379 "@code{SIGALRM} beforehand, since the default action is to terminate\n"
380 "the process.\n\n"
381 "The return value indicates the time remaining for the previous alarm,\n"
382 "if any. The new value replaces the previous alarm. If there was\n"
383 "no previous alarm, the return value is zero.")
384 #define FUNC_NAME s_scm_alarm
385 {
386 unsigned int j;
387 SCM_VALIDATE_INUM (1, i);
388 j = alarm (SCM_INUM (i));
389 return SCM_MAKINUM (j);
390 }
391 #undef FUNC_NAME
392
393 #ifdef HAVE_SETITIMER
394 SCM_DEFINE (scm_setitimer, "setitimer", 5, 0, 0,
395 (SCM which_timer,
396 SCM interval_seconds, SCM interval_microseconds,
397 SCM value_seconds, SCM value_microseconds),
398 "Set the timer specified by @var{which_timer} according to the given\n"
399 "@var{interval_seconds}, @var{interval_microseconds},\n"
400 "@var{value_seconds}, and @var{value_microseconds} values.\n"
401 "\n"
402 "Return information about the timer's previous setting."
403 "\n"
404 "Errors are handled as described in the guile info pages under ``POSIX\n"
405 "Interface Conventions''.\n"
406 "\n"
407 "The timers available are: @code{ITIMER_REAL}, @code{ITIMER_VIRTUAL},\n"
408 "and @code{ITIMER_PROF}.\n"
409 "\n"
410 "The return value will be a list of two cons pairs representing the\n"
411 "current state of the given timer. The first pair is the seconds and\n"
412 "microseconds of the timer @code{it_interval}, and the second pair is\n"
413 "the seconds and microseconds of the timer @code{it_value}.")
414 #define FUNC_NAME s_scm_setitimer
415 {
416 int rv;
417 int c_which_timer;
418 struct itimerval new_timer;
419 struct itimerval old_timer;
420
421 c_which_timer = SCM_NUM2INT(1, which_timer);
422 new_timer.it_interval.tv_sec = SCM_NUM2LONG(2, interval_seconds);
423 new_timer.it_interval.tv_usec = SCM_NUM2LONG(3, interval_microseconds);
424 new_timer.it_value.tv_sec = SCM_NUM2LONG(4, value_seconds);
425 new_timer.it_value.tv_usec = SCM_NUM2LONG(5, value_microseconds);
426
427 SCM_SYSCALL(rv = setitimer(c_which_timer, &new_timer, &old_timer));
428
429 if(rv != 0)
430 SCM_SYSERROR;
431
432 return scm_list_2(scm_cons(scm_long2num(old_timer.it_interval.tv_sec),
433 scm_long2num(old_timer.it_interval.tv_usec)),
434 scm_cons(scm_long2num(old_timer.it_value.tv_sec),
435 scm_long2num(old_timer.it_value.tv_usec)));
436 }
437 #undef FUNC_NAME
438 #endif /* HAVE_SETITIMER */
439
440 #ifdef HAVE_GETITIMER
441 SCM_DEFINE (scm_getitimer, "getitimer", 1, 0, 0,
442 (SCM which_timer),
443 "Return information about the timer specified by @var{which_timer}"
444 "\n"
445 "Errors are handled as described in the guile info pages under ``POSIX\n"
446 "Interface Conventions''.\n"
447 "\n"
448 "The timers available are: @code{ITIMER_REAL}, @code{ITIMER_VIRTUAL},\n"
449 "and @code{ITIMER_PROF}.\n"
450 "\n"
451 "The return value will be a list of two cons pairs representing the\n"
452 "current state of the given timer. The first pair is the seconds and\n"
453 "microseconds of the timer @code{it_interval}, and the second pair is\n"
454 "the seconds and microseconds of the timer @code{it_value}.")
455 #define FUNC_NAME s_scm_getitimer
456 {
457 int rv;
458 int c_which_timer;
459 struct itimerval old_timer;
460
461 c_which_timer = SCM_NUM2INT(1, which_timer);
462
463 SCM_SYSCALL(rv = getitimer(c_which_timer, &old_timer));
464
465 if(rv != 0)
466 SCM_SYSERROR;
467
468 return scm_list_2(scm_cons(scm_long2num(old_timer.it_interval.tv_sec),
469 scm_long2num(old_timer.it_interval.tv_usec)),
470 scm_cons(scm_long2num(old_timer.it_value.tv_sec),
471 scm_long2num(old_timer.it_value.tv_usec)));
472 }
473 #undef FUNC_NAME
474 #endif /* HAVE_GETITIMER */
475
476 #ifdef HAVE_PAUSE
477 SCM_DEFINE (scm_pause, "pause", 0, 0, 0,
478 (),
479 "Pause the current process (thread?) until a signal arrives whose\n"
480 "action is to either terminate the current process or invoke a\n"
481 "handler procedure. The return value is unspecified.")
482 #define FUNC_NAME s_scm_pause
483 {
484 pause ();
485 return SCM_UNSPECIFIED;
486 }
487 #undef FUNC_NAME
488 #endif
489
490 SCM_DEFINE (scm_sleep, "sleep", 1, 0, 0,
491 (SCM i),
492 "Wait for the given number of seconds (an integer) or until a signal\n"
493 "arrives. The return value is zero if the time elapses or the number\n"
494 "of seconds remaining otherwise.")
495 #define FUNC_NAME s_scm_sleep
496 {
497 unsigned long j;
498 SCM_VALIDATE_INUM_MIN (1, i,0);
499 #ifdef USE_THREADS
500 j = scm_thread_sleep (SCM_INUM(i));
501 #else
502 j = sleep (SCM_INUM(i));
503 #endif
504 return scm_ulong2num (j);
505 }
506 #undef FUNC_NAME
507
508 #if defined(USE_THREADS) || defined(HAVE_USLEEP) || defined(__MINGW32__)
509 SCM_DEFINE (scm_usleep, "usleep", 1, 0, 0,
510 (SCM i),
511 "Sleep for I microseconds. @code{usleep} is not available on\n"
512 "all platforms.")
513 #define FUNC_NAME s_scm_usleep
514 {
515 SCM_VALIDATE_INUM_MIN (1, i,0);
516
517 #ifdef USE_THREADS
518 /* If we have threads, we use the thread system's sleep function. */
519 {
520 unsigned long j = scm_thread_usleep (SCM_INUM (i));
521 return scm_ulong2num (j);
522 }
523 #else
524 #ifdef USLEEP_RETURNS_VOID
525 usleep (SCM_INUM (i));
526 return SCM_INUM0;
527 #else
528 {
529 int j = usleep (SCM_INUM (i));
530 return SCM_MAKINUM (j);
531 }
532 #endif
533 #endif
534 }
535 #undef FUNC_NAME
536 #endif /* USE_THREADS || HAVE_USLEEP || __MINGW32__ */
537
538 SCM_DEFINE (scm_raise, "raise", 1, 0, 0,
539 (SCM sig),
540 "Sends a specified signal @var{sig} to the current process, where\n"
541 "@var{sig} is as described for the kill procedure.")
542 #define FUNC_NAME s_scm_raise
543 {
544 SCM_VALIDATE_INUM (1, sig);
545 SCM_DEFER_INTS;
546 if (kill (getpid (), (int) SCM_INUM (sig)) != 0)
547 SCM_SYSERROR;
548 SCM_ALLOW_INTS;
549 return SCM_UNSPECIFIED;
550 }
551 #undef FUNC_NAME
552
553 \f
554
555 void
556 scm_init_scmsigs ()
557 {
558 SCM thunk;
559 int i;
560
561 signal_handlers =
562 SCM_VARIABLE_LOC (scm_c_define ("signal-handlers",
563 scm_c_make_vector (NSIG, SCM_BOOL_F)));
564 /* XXX - use scm_c_make_gsubr here instead of `define'? */
565 thunk = scm_c_define_gsubr ("%deliver-signals", 0, 0, 0,
566 sys_deliver_signals);
567 signal_async = scm_system_async (thunk);
568
569 for (i = 0; i < NSIG; i++)
570 {
571 got_signal[i] = 0;
572 #ifdef HAVE_SIGACTION
573 orig_handlers[i].sa_handler = SIG_ERR;
574
575 #else
576 orig_handlers[i] = SIG_ERR;
577 #endif
578
579 #ifdef HAVE_RESTARTABLE_SYSCALLS
580 /* If HAVE_RESTARTABLE_SYSCALLS is defined, it's important that
581 signals really are restartable. don't rely on the same
582 run-time that configure got: reset the default for every signal.
583 */
584 #ifdef HAVE_SIGINTERRUPT
585 siginterrupt (i, 0);
586 #elif defined(SA_RESTART)
587 {
588 struct sigaction action;
589
590 sigaction (i, NULL, &action);
591 if (!(action.sa_flags & SA_RESTART))
592 {
593 action.sa_flags |= SA_RESTART;
594 sigaction (i, &action, NULL);
595 }
596 }
597 #endif
598 /* if neither siginterrupt nor SA_RESTART are available we may
599 as well assume that signals are always restartable. */
600 #endif
601 }
602
603 scm_c_define ("NSIG", scm_long2num (NSIG));
604 scm_c_define ("SIG_IGN", scm_long2num ((long) SIG_IGN));
605 scm_c_define ("SIG_DFL", scm_long2num ((long) SIG_DFL));
606 #ifdef SA_NOCLDSTOP
607 scm_c_define ("SA_NOCLDSTOP", scm_long2num (SA_NOCLDSTOP));
608 #endif
609 #ifdef SA_RESTART
610 scm_c_define ("SA_RESTART", scm_long2num (SA_RESTART));
611 #endif
612
613 #if defined(HAVE_SETITIMER) || defined(HAVE_GETITIMER)
614 /* Stuff needed by setitimer and getitimer. */
615 scm_c_define ("ITIMER_REAL", SCM_MAKINUM (ITIMER_REAL));
616 scm_c_define ("ITIMER_VIRTUAL", SCM_MAKINUM (ITIMER_VIRTUAL));
617 scm_c_define ("ITIMER_PROF", SCM_MAKINUM (ITIMER_PROF));
618 #endif /* defined(HAVE_SETITIMER) || defined(HAVE_GETITIMER) */
619
620 #include "libguile/scmsigs.x"
621 }
622
623
624 /*
625 Local Variables:
626 c-file-style: "gnu"
627 End:
628 */