scsh-conservatory
/
scsh-0.6
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rewrote signal checks and added handler for all scsh interrupts.

This commit is contained in:
mainzelm 2000-12-21 13:25:21 +00:00
parent 3a9832252b
commit cfb1e34b08
2 changed files with 108 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

207
c/unix/event.c
View File

@ -13,6 +13,8 @@
#include "c-mods.h" #include "c-mods.h"
#include "scheme48vm.h" #include "scheme48vm.h"
#include "event.h" #include "event.h"
#include "../scsh/scsh_aux.h"
#include "../scsh/signals1.h"
/* turning interrupts and I/O readiness into events */ /* turning interrupts and I/O readiness into events */
@ -25,18 +27,7 @@ static void when_alarm_interrupt();
static void when_sigpipe_interrupt(); static void when_sigpipe_interrupt();
//JMG: //JMG:
static void when_child_interrupt(); static void when_scsh_interrupt();
static void when_hup_interrupt();
static void when_cont_interrupt();
static void when_quit_interrupt();
static void when_term_interrupt();
static void when_tstp_interrupt();
static void when_usr1_interrupt();
static void when_usr2_interrupt();
bool s48_setcatcher(int signum, void (*catcher)(int)); bool s48_setcatcher(int signum, void (*catcher)(int));
@ -56,13 +47,42 @@ s48_sysdep_init(void)
} }
//JMG: for scsh //JMG: for scsh
if (!s48_setcatcher(SIGCHLD, when_child_interrupt) s48_setcatcher(SIGCHLD, when_scsh_interrupt);
|| !s48_setcatcher(SIGHUP, when_hup_interrupt)) { s48_setcatcher(SIGCONT, when_scsh_interrupt);
fprintf(stderr, s48_setcatcher(SIGHUP, when_scsh_interrupt);
"Failed to install signal handler for SIGCHLD, errno = %d\n", s48_setcatcher(SIGQUIT, when_scsh_interrupt);
errno); s48_setcatcher(SIGTERM, when_scsh_interrupt);
exit(1); s48_setcatcher(SIGTSTP, when_scsh_interrupt);
} s48_setcatcher(SIGUSR1, when_scsh_interrupt);
s48_setcatcher(SIGUSR2, when_scsh_interrupt);
#ifdef SIGINFO
s48_setcatcher(SIGINFO, when_scsh_interrupt);
#endif
#ifdef SIGIO
s48_setcatcher(SIGIO, when_scsh_interrupt);
#endif
#ifdef SIGPOLL
s48_setcatcher(SIGPOLL, when_scsh_interrupt);
#endif
#ifdef SIGPROF
s48_setcatcher(SIGPROF, when_scsh_interrupt);
#endif
#ifdef SIGPWR
s48_setcatcher(SIGPWR, when_scsh_interrupt);
#endif
#ifdef SIGVTALRM
s48_setcatcher(SIGVTALRM, when_scsh_interrupt);
#endif
#ifdef SIGWINCH
s48_setcatcher(SIGWINCH, when_scsh_interrupt);
#endif
#ifdef SIGXCPU
s48_setcatcher(SIGXCPU, when_scsh_interrupt);
#endif
#ifdef SIGXFSZ
s48_setcatcher(SIGXFSZ, when_scsh_interrupt);
#endif
s48_start_alarm_interrupts(); s48_start_alarm_interrupts();
} }
@ -76,15 +96,21 @@ s48_setcatcher(int signum, void (*catcher)(int))
{ {
struct sigaction sa; struct sigaction sa;
if (sigaction(signum, (struct sigaction *)NULL, &sa) != 0) if (sigaction(signum, (struct sigaction *)NULL, &sa) != 0){
return (FALSE); fprintf(stderr, "Failed to get sigaction for signal %d\n", signum);
if (sa.sa_handler == SIG_IGN) exit(1);
return (TRUE); }
// JMG: what's the point of not setting the handler in this case?
// if (sa.sa_handler == SIG_IGN)
// return (TRUE);
sa.sa_handler = catcher; sa.sa_handler = catcher;
sigemptyset(&sa.sa_mask); sigemptyset(&sa.sa_mask);
sa.sa_flags = 0; sa.sa_flags = 0;
if (sigaction(signum, &sa, (struct sigaction *)NULL) != 0) if (sigaction(signum, &sa, (struct sigaction *)NULL) != 0){
return (FALSE); fprintf(stderr, "Failed to define handler for signal %d\n", signum);
exit(1);
}
return (TRUE); return (TRUE);
} }
@ -617,88 +643,18 @@ queue_ready_ports(bool wait, long seconds, long ticks)
//JMG: for scsh //JMG: for scsh
static int child_interrupt_count = 0; static long interrupt_count[32];
static void static void when_scsh_interrupt(int signo)
when_child_interrupt(int ign)
{ {
child_interrupt_count += 1; interrupt_count[sig2int[signo]] +=1;
NOTE_EVENT; NOTE_EVENT;
return; return;
} }
static int hup_interrupt_count = 0;
static void
when_hup_interrupt(int ign)
{
hup_interrupt_count += 1;
NOTE_EVENT;
return;
}
static int cont_interrupt_count = 0;
static void
when_cont_interrupt(int ign)
{
cont_interrupt_count += 1;
NOTE_EVENT;
return;
}
static int quit_interrupt_count = 0;
static void
when_quit_interrupt(int ign)
{
quit_interrupt_count += 1;
NOTE_EVENT;
return;
}
static int term_interrupt_count = 0;
static void
when_term_interrupt(int ign)
{
term_interrupt_count += 1;
NOTE_EVENT;
return;
}
static int tstp_interrupt_count = 0;
static void
when_tstp_interrupt(int ign)
{
tstp_interrupt_count += 1;
NOTE_EVENT;
return;
}
static int usr1_interrupt_count = 0;
static void
when_usr1_interrupt(int ign)
{
usr1_interrupt_count += 1;
NOTE_EVENT;
return;
}
static int usr2_interrupt_count = 0;
static void
when_usr2_interrupt(int ign)
{
usr2_interrupt_count += 1;
NOTE_EVENT;
return;
}
/* /*
* This procedure is called periodically by the VM (if you uncomment the * This procedure is called periodically by the VM .
* call to it in s48_get_next_event() in c/unix/event.c).
* *
* s48_set_os_signal() is a VM procedure. The two arguments are the type * s48_set_os_signal() is a VM procedure. The two arguments are the type
* of interrupt and one other value which can be used to return whatever * of interrupt and one other value which can be used to return whatever
@ -718,50 +674,19 @@ when_usr2_interrupt(int ign)
* The handler is called with all interrupts disabled. They are * The handler is called with all interrupts disabled. They are
* reenabled when the handler returns (or if done by hand). * reenabled when the handler returns (or if done by hand).
*/ */
enum scsh_os_signal{
scsh_os_signal_io_completion,
scsh_os_signal_post_gc,
scsh_os_signal_keyboard,
scsh_os_signal_alarm,
scsh_os_signal_chld ,
scsh_os_signal_cont,
scsh_os_signal_hup,
scsh_os_signal_quit,
scsh_os_signal_term,
scsh_os_signal_tstp,
scsh_os_signal_usr1,
scsh_os_signal_usr2,
scsh_os_signal_info,
scsh_os_signal_io,
scsh_os_signal_poll,
scsh_os_signal_prof,
scsh_os_signal_pwr,
scsh_os_signal_urg,
scsh_os_signal_vtalrm,
scsh_os_signal_winch,
scsh_os_signal_xcpu,
scsh_os_signal_xfsz
};
int int
s48_os_signal_pending(void) { s48_os_signal_pending(void) {
if (child_interrupt_count > 0) { int i;
// fprintf(stderr, "cld c %d", child_interrupt_count); for (i = 0; i < max_sig; i++){
block_interrupts(); if (interrupt_count[i] > 0){
--child_interrupt_count; block_interrupts();
allow_interrupts(); --interrupt_count[i];
s48_set_os_signal(S48_UNSAFE_ENTER_FIXNUM(scsh_os_signal_chld), allow_interrupts();
S48_UNSAFE_ENTER_FIXNUM(SIGCHLD)); s48_set_os_signal(S48_UNSAFE_ENTER_FIXNUM(i),
return TRUE; S48_UNSAFE_ENTER_FIXNUM(0));
return TRUE;
}
} }
else if (hup_interrupt_count > 0){ return FALSE;
fprintf(stderr, "hup c %d", hup_interrupt_count);
block_interrupts();
--hup_interrupt_count;
allow_interrupts();
s48_set_os_signal(S48_UNSAFE_ENTER_FIXNUM(scsh_os_signal_hup),
S48_UNSAFE_ENTER_FIXNUM(SIGHUP));
return TRUE;
}
else return FALSE;
} }

83
scsh/scsh_aux.c
View File

@ -1,53 +1,54 @@
/* Copyright (c) 2000 by Martin Gasbichler
See file COPYING. */
#include "scsh_aux.h" #include "scsh_aux.h"
#include <signal.h> #include <signal.h>
#ifndef SIGURG
#define SIGURG 9999
#endif
#ifndef SIGXCPU
#define SIGXCPU 9999
#endif
#ifndef SIGXFSZ
#define SIGXFSZ 9999
#endif
#ifndef SIGVTALRM
#define SIGVTALRM 9999
#endif
#ifndef SIGPROF
#define SIGPROF 9999
#endif
#ifndef SIGWINCH
#define SIGWINCH 9999
#endif
#ifndef SIGIO
#define SIGIO 9999
#endif
#ifndef SIGPWR
#define SIGPWR 9999
#endif
int main(int argc, char* argv[]){ int main(int argc, char* argv[]){
int signr = atoi(argv[1]); int signr = atoi(argv[1]);
switch (signr) { switch (signr) {
case SIGHUP : printf("scshint_hup"); break; case SIGINT : printf("scshint_keyboard"); break;
case SIGINT : printf("scshint_keyboard"); break; case SIGALRM : printf("scshint_alarm"); break;
case SIGQUIT : printf("scshint_quit"); break; case SIGCHLD : printf("scshint_chld"); break;
case SIGUSR1 : printf("scshint_usr1"); break; case SIGCONT : printf("scshint_cont"); break;
case SIGUSR2 : printf("scshint_usr2"); break; case SIGHUP : printf("scshint_hup"); break;
case SIGALRM : printf("scshint_alarm"); break; case SIGQUIT : printf("scshint_quit"); break;
case SIGTERM : printf("scshint_term"); break; case SIGTERM : printf("scshint_term"); break;
case SIGCHLD : printf("scshint_chld"); break; case SIGTSTP : printf("scshint_tstp"); break;
case SIGCONT : printf("scshint_cont"); break; case SIGUSR1 : printf("scshint_usr1"); break;
case SIGTSTP : printf("scshint_tstp"); break; case SIGUSR2 : printf("scshint_usr2"); break;
case SIGURG : printf("scshint_urg"); break; #ifdef SIGINFO
case SIGXCPU : printf("scshint_xcpu"); break; case SIGINFO : printf("scshint_info"); break;
case SIGXFSZ : printf("scshint_xfsz"); break; #endif
#ifdef SIGIO
case SIGIO : printf("scshint_io"); break;
#endif
#ifdef SIGPOLL
case SIGPOLL : printf("scshint_poll"); break;
#endif
#ifdef SIGPROF
case SIGPROF : printf("scshint_prof"); break;
#endif
#ifdef SIGPWR
case SIGPWR : printf("scshint_pwr"); break;
#endif
#ifdef SIGURG
case SIGURG : printf("scshint_urg"); break;
#endif
#ifdef SIGVTALRM
case SIGVTALRM : printf("scshint_vtalrm"); break; case SIGVTALRM : printf("scshint_vtalrm"); break;
case SIGPROF : printf("scshint_prof"); break; #endif
case SIGWINCH : printf("scshint_winch"); break; #ifdef SIGWINCH
case SIGIO : printf("scshint_io"); break;/* aka SIGPOLL*/ case SIGWINCH : printf("scshint_winch"); break;
case SIGPWR : printf("scshint_pwr"); break; #endif
#ifdef SIGXCPU
case SIGXCPU : printf("scshint_xcpu"); break;
#endif
#ifdef SIGXFSZ
case SIGXFSZ : printf("scshint_xfsz"); break;
#endif
default: printf("-1");} default: printf("-1");}
return 0; return 0;