293 lines
7.4 KiB
C
293 lines
7.4 KiB
C
/* Need to define sig2interrupt vector.
|
|
** Interrupt-system mutators should probably hold interrupts while they
|
|
** operate.
|
|
*/
|
|
|
|
#include <unistd.h>
|
|
#include <sys/types.h>
|
|
#include <signal.h>
|
|
#include "cstuff.h"
|
|
|
|
/* Make sure our exports match up w/the implementation: */
|
|
#include "sighandlers1.h"
|
|
|
|
extern int errno;
|
|
|
|
extern scheme_value Spending_interruptsS, Sinterrupt_handlersS;
|
|
|
|
/* Translate Unix signal numbers to S48 interrupt numbers.
|
|
** alarm, keyboard (^C, SIGINT), and memory shortage are 0, 1, and 2.
|
|
*/
|
|
|
|
static int sig2interrupt(int signal)
|
|
{
|
|
switch (signal) {
|
|
case SIGALRM: return 0; /* Already defined by S48. */
|
|
case SIGCHLD: return 3;
|
|
case SIGCONT: return 4;
|
|
case SIGHUP: return 5;
|
|
case SIGINT: return 1; /* Already defined by S48. */
|
|
case SIGQUIT: return 6;
|
|
case SIGTERM: return 7;
|
|
case SIGTSTP: return 8;
|
|
case SIGUSR1: return 9;
|
|
case SIGUSR2: return 10;
|
|
|
|
#ifdef SIGINFO
|
|
case SIGINFO: return 11;
|
|
#endif
|
|
#ifdef SIGIO
|
|
case SIGIO: return 12;
|
|
#endif
|
|
#ifdef SIGPOLL
|
|
case SIGPOLL: return 13;
|
|
#endif
|
|
#ifdef SIGPROF
|
|
case SIGPROF: return 14;
|
|
#endif
|
|
#ifdef SIGPWR
|
|
case SIGPWR: return 15;
|
|
#endif
|
|
#ifdef SIGURG
|
|
case SIGURG: return 16;
|
|
#endif
|
|
#ifdef SIGVTALRM
|
|
case SIGVTALRM: return 17;
|
|
#endif
|
|
#ifdef SIGWINCH
|
|
case SIGWINCH: return 18;
|
|
#endif
|
|
#ifdef SIGXCPU
|
|
case SIGXCPU: return 19;
|
|
#endif
|
|
#ifdef SIGXFSZ
|
|
case SIGXFSZ: return 20;
|
|
#endif
|
|
default: return -1;
|
|
}
|
|
}
|
|
|
|
/* Hack the blocked-signal mask.
|
|
*******************************************************************************
|
|
*/
|
|
|
|
|
|
#include "machine/sigset.h"
|
|
|
|
int set_procmask(int hi, int lo, int *old_lo_p)
|
|
{
|
|
sigset_t mask, old_mask;
|
|
int old_hi;
|
|
|
|
make_sigset(&mask, hi, lo);
|
|
|
|
sigprocmask(SIG_SETMASK, &mask, &old_mask);
|
|
split_sigset(old_mask, &old_hi, old_lo_p);
|
|
return old_hi;
|
|
}
|
|
|
|
|
|
int get_procmask(int *old_lo_p)
|
|
{
|
|
sigset_t old_mask;
|
|
int old_hi;
|
|
|
|
sigprocmask(SIG_SETMASK, NULL, &old_mask);
|
|
split_sigset(old_mask, &old_hi, old_lo_p);
|
|
return old_hi;
|
|
}
|
|
|
|
|
|
/* Set/Get signal handlers
|
|
*******************************************************************************
|
|
*/
|
|
|
|
static void scm_handle_sig(int sig)
|
|
{
|
|
Spending_interruptsS |= (1<<sig2interrupt(sig));
|
|
}
|
|
|
|
|
|
scheme_value set_sig_handler(int sig, scheme_value handler, int flags,
|
|
scheme_value *ohandler, int *oflags)
|
|
{
|
|
struct sigaction new, old;
|
|
int intnum = sig2interrupt(sig);
|
|
scheme_value old_scsh_handler;
|
|
|
|
/* intnum in range? */
|
|
if( intnum >= VECTOR_LENGTH(Sinterrupt_handlersS) ) {
|
|
*ohandler = SCHFALSE;
|
|
return ENTER_FIXNUM(-1);
|
|
}
|
|
|
|
/* We may need this for ohandler later, but it may get clobbered when
|
|
** when we set the new handler, so stash it away for now.
|
|
*/
|
|
old_scsh_handler = VECTOR_REF(Sinterrupt_handlersS, intnum);
|
|
|
|
sigemptyset(&new.sa_mask); /* WTF */
|
|
new.sa_flags = flags;
|
|
|
|
if( handler == SCHFALSE ) {
|
|
new.sa_handler = SIG_IGN;
|
|
VECTOR_REF(Sinterrupt_handlersS, intnum) = SCHFALSE;
|
|
}
|
|
|
|
/* This *really* sets the Unix signal handler to SIG_DFL.
|
|
** What usually happens isn't this -- what usually happens is that
|
|
** we establish a special Scheme handler that does the default, so
|
|
** that it is subject to S48's blocking machinery.
|
|
*/
|
|
else if( handler == SCHTRUE ) {
|
|
new.sa_handler = SIG_DFL;
|
|
VECTOR_REF(Sinterrupt_handlersS, intnum) = SCHFALSE;
|
|
}
|
|
|
|
else {
|
|
new.sa_handler = scm_handle_sig;
|
|
|
|
VECTOR_REF(Sinterrupt_handlersS, intnum) = handler;
|
|
/* Do other stuff. */
|
|
}
|
|
|
|
if( sigaction(sig, &new, &old) ) {
|
|
*ohandler = SCHFALSE;
|
|
return ENTER_FIXNUM(errno);
|
|
}
|
|
|
|
*oflags = old.sa_flags;
|
|
if( old.sa_handler == SIG_IGN ) *ohandler = SCHFALSE;
|
|
else if( old.sa_handler == SIG_DFL ) *ohandler = SCHTRUE;
|
|
else if( old.sa_handler == scm_handle_sig ) *ohandler = old_scsh_handler;
|
|
else *ohandler = ENTER_FIXNUM(-1); /* Unknown signal handler. */
|
|
return SCHFALSE;
|
|
}
|
|
|
|
|
|
scheme_value get_sig_handler(int signal, scheme_value *handler, int *flags)
|
|
{
|
|
struct sigaction old;
|
|
|
|
if( sigaction(signal, NULL, &old) ) {
|
|
*handler = SCHFALSE;
|
|
return ENTER_FIXNUM(errno);
|
|
}
|
|
|
|
*flags = old.sa_flags;
|
|
|
|
if( old.sa_handler == SIG_IGN ) *handler = SCHFALSE;
|
|
|
|
else if( old.sa_handler == SIG_DFL ) *handler = SCHTRUE;
|
|
|
|
else if( old.sa_handler == scm_handle_sig ) {
|
|
int intnum = sig2interrupt(signal);
|
|
|
|
/* intnum in range? */
|
|
if( intnum >= VECTOR_LENGTH(Sinterrupt_handlersS) ) {
|
|
*handler = SCHFALSE;
|
|
return ENTER_FIXNUM(-1);
|
|
}
|
|
|
|
*handler = VECTOR_REF(Sinterrupt_handlersS, intnum);
|
|
}
|
|
|
|
else *handler = ENTER_FIXNUM(-1); /* Unknown signal handler. */
|
|
|
|
return SCHFALSE;
|
|
}
|
|
|
|
|
|
/* Return true if SIGNAL's default action is definitely to be ignored. */
|
|
/* This should be inlined by a good compiler. */
|
|
|
|
static int sig_def_is_ignored(int signal)
|
|
{
|
|
return
|
|
/* Posix signals */
|
|
signal == SIGALRM || signal == SIGHUP ||
|
|
signal == SIGINT || signal == SIGQUIT ||
|
|
signal == SIGTERM || signal == SIGUSR1 ||
|
|
signal == SIGUSR2
|
|
|
|
/* Non-Posix signals, when present. */
|
|
#ifdef SIGINFO
|
|
|| signal == SIGINFO
|
|
#endif
|
|
#ifdef SIGPOLL
|
|
|| signal == SIGPOLL
|
|
#endif
|
|
#ifdef SIGPROF
|
|
|| signal == SIGPROF
|
|
#endif
|
|
#ifdef SIGVTALRM
|
|
|| signal == SIGVTALRM
|
|
#endif
|
|
#ifdef SIGXCPU
|
|
|| signal == SIGXCPU
|
|
#endif
|
|
#ifdef SIGXFSZ
|
|
|| signal == SIGXFSZ
|
|
#endif
|
|
#ifdef SIGIO
|
|
|| signal == SIGIO /* BSD => ignore; SVR4 => terminate */
|
|
#endif
|
|
;
|
|
}
|
|
|
|
|
|
/* This guy is responsible for making the default action for a
|
|
** Unix signal happen. Because S48's signal handler system is
|
|
** interposed between delivery-to-the-process and
|
|
** delivery-to-the-scheme-handler, when the user sets a signal
|
|
** handler to default, we install a Scheme proc that calls this
|
|
** guy, instead of just slapping a SIGDFL in as the Unix handler.
|
|
** We only have to do this for signals whose default isn't "ignore," i.e.:
|
|
** Posix: SIGALRM SIGHUP SIGINT SIGQUIT SIGTERM SIGUSR1 SIGUSR2
|
|
** Non-Posix: SIGINFO SIGPOLL SIGPROF SIGVTALRM SIGXCPU SIGXFSZ SIGIO
|
|
** This way, the S48 signal-blocking mechanism can work.
|
|
**
|
|
** Weird, I know.
|
|
*/
|
|
void do_default_sigaction(int signal)
|
|
{
|
|
sigset_t ss, old_ss;
|
|
struct sigaction default_action, old_action;
|
|
|
|
if( !sig_def_is_ignored(signal) ) {
|
|
|
|
/* OK -- signal's default *isn't* "ignore," so we have to do it. */
|
|
sigfillset(&ss); /* Block everyone. */
|
|
sigprocmask(SIG_SETMASK, &ss, &old_ss);
|
|
|
|
default_action.sa_handler = SIG_DFL; /* Set for default. */
|
|
sigemptyset(&default_action.sa_mask);
|
|
default_action.sa_flags = 0;
|
|
sigaction(signal, &default_action, &old_action);
|
|
|
|
raise(signal); /* Raise the signal. */
|
|
sigdelset(&ss, signal);
|
|
sigprocmask(SIG_SETMASK, &ss, 0); /* Handle it. */
|
|
|
|
/* Most likely, we'll never get to here, as the default for
|
|
** the signals we're handling is "terminate," but we'll play it safe.
|
|
*/
|
|
sigaction(signal, &old_action, 0); /* Restore old handler, */
|
|
sigprocmask(SIG_SETMASK, &old_ss, 0); /* and mask. */
|
|
}
|
|
}
|
|
|
|
|
|
/* Install a new signal-handler vector.
|
|
** I use this because the default one is only 3 entries long, and I
|
|
** don't want to modify the S48 source. So I'll just install my own
|
|
** at run-time.
|
|
** It's not a hack, it's a kluge.
|
|
*/
|
|
|
|
void install_new_handler_vector(scheme_value handlers)
|
|
{
|
|
extern scheme_value Sinterrupt_handlersS;
|
|
Sinterrupt_handlersS = handlers;
|
|
}
|