* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
+#include <stdlib.h>
#include <signal.h>
#ifdef mach /* KLUDGE: #ifdef on lowercase symbols? Ick. -- WHN 19990904 */
* In that case, the Lisp-level handler is stored in interrupt_handlers[..]
* and interrupt_low_level_handlers[..] is cleared.
*
- * However, some signals need special handling, e.g. the SIGSEGV (for
- * Linux) or SIGBUS (for FreeBSD) used by the garbage collector to
- * detect violations of write protection, because some cases of such
- * signals are handled at C level and never passed on to Lisp. For
- * such signals, we still store any Lisp-level handler in
- * interrupt_handlers[..], but for the outermost handle we use the
- * value from interrupt_low_level_handlers[..], instead of the
- * ordinary interrupt_handle_now(..) or interrupt_handle_later(..).
+ * However, some signals need special handling, e.g.
*
- * -- WHN 20000728 */
+ * o the SIGSEGV (for e.g. Linux) or SIGBUS (for e.g. FreeBSD) used by the
+ * garbage collector to detect violations of write protection,
+ * because some cases of such signals (e.g. GC-related violations of
+ * write protection) are handled at C level and never passed on to
+ * Lisp. For such signals, we still store any Lisp-level handler
+ * in interrupt_handlers[..], but for the outermost handle we use
+ * the value from interrupt_low_level_handlers[..], instead of the
+ * ordinary interrupt_handle_now(..) or interrupt_handle_later(..).
+ *
+ * o the SIGTRAP (Linux/Alpha) which Lisp code uses to handle breakpoints,
+ * pseudo-atomic sections, and some classes of error (e.g. "function
+ * not defined"). This never goes anywhere near the Lisp handlers at all.
+ * See runtime/alpha-arch.c and code/signal.lisp
+ *
+ * - WHN 20000728, dan 20010128 */
+
+
void (*interrupt_low_level_handlers[NSIG]) (int, siginfo_t*, void*) = {0};
union interrupt_handler interrupt_handlers[NSIG];
(lispobj *)(*os_context_register_addr(context, reg_ALLOC));
#ifdef alpha
if ((long)dynamic_space_free_pointer & 1) {
- lose("dead in fake_foreign_function_call, context = %x", context);
+ lose("dead in fake_foreign_function_call, context = %x", context);
}
#endif
#endif
/* There is a small window during call where the callee's
* frame isn't built yet. */
if (LowtagOf(*os_context_register_addr(context, reg_CODE))
- == type_FunctionPointer) {
+ == type_FunPointer) {
/* We have called, but not built the new frame, so
* build it for them. */
current_control_frame_pointer[0] =
oldcont = (lispobj)(*os_context_register_addr(context, reg_OCFP));
}
}
- /* ### We can't tell if we are still in the caller if it had to
- * reg_ALLOCate the stack frame due to stack arguments. */
+ /* ### We can't tell whether we are still in the caller if it had
+ * to reg_ALLOCate the stack frame due to stack arguments. */
/* ### Can anything strange happen during return? */
- else
+ else {
/* normal case */
oldcont = (lispobj)(*os_context_register_addr(context, reg_CFP));
+ }
current_control_stack_pointer = current_control_frame_pointer + 8;
* FREE_INTERRUPT_CONTEXT_INDEX? If so, we should say so. And
* perhaps yes, unbind_to_here() really would be clearer and less
* fragile.. */
+ /* dan (2001.08.10) thinks the above supposition is probably correct */
unbind();
#ifdef reg_ALLOC
interrupt_internal_error(int signal, siginfo_t *info, os_context_t *context,
boolean continuable)
{
- lispobj context_sap;
+ lispobj context_sap = 0;
fake_foreign_function_call(context);
}
}
+/* This function handles pending interrupts. Note that in C/kernel
+ * terms we dealt with the signal already; we just haven't decided
+ * whether to call a Lisp handler or do a GC or something like that.
+ * If it helps, you can think of pending_{signal,mask,info} as a
+ * one-element queue of signals that we have acknowledged but not
+ * processed */
+
void
interrupt_handle_pending(os_context_t *context)
{
+#ifndef __i386__
boolean were_in_lisp = !foreign_function_call_active;
+#endif
SetSymbolValue(INTERRUPT_PENDING, NIL);
}
}
- /* FIXME: How come we unconditionally copy from pending_mask into
- * the context, and then test whether pending_signal is set? If
- * pending_signal wasn't set, how could pending_mask be valid? */
+ /* FIXME: This isn't very clear. It would be good to reverse
+ * engineer it and rewrite the code more clearly, or write a clear
+ * explanation of what's going on in the comments, or both.
+ *
+ * WHN's question 1a: How come we unconditionally copy from
+ * pending_mask into the context, and then test whether
+ * pending_signal is set?
+ *
+ * WHN's question 1b: If pending_signal wasn't set, how could
+ * pending_mask be valid?
+ *
+ * Dan Barlow's reply (sbcl-devel 2001-03-13): And the answer is -
+ * or appears to be - because interrupt_maybe_gc set it that way
+ * (look in the #ifndef __i386__ bit). We can't GC during a
+ * pseudo-atomic, so we set maybe_gc_pending=1 and
+ * arch_set_pseudo_atomic_interrupted(..) When we come out of
+ * pseudo_atomic we're marked as interrupted, so we call
+ * interrupt_handle_pending, which does the GC using the pending
+ * context (it needs a context so that it has registers to use as
+ * GC roots) then notices there's no actual interrupt handler to
+ * call, so doesn't. That's the second question [1b] answered,
+ * anyway. Why we still need to copy the pending_mask into the
+ * context given that we're now done with the context anyway, I
+ * couldn't say. */
memcpy(os_context_sigmask_addr(context), &pending_mask, sizeof(sigset_t));
sigemptyset(&pending_mask);
if (pending_signal) {
interrupt_handle_now(int signal, siginfo_t *info, void *void_context)
{
os_context_t *context = (os_context_t*)void_context;
- int were_in_lisp;
+#ifndef __i386__
+ boolean were_in_lisp;
+#endif
union interrupt_handler handler;
-#ifdef __linux__
- SET_FPU_CONTROL_WORD(context->__fpregs_mem.cw);
-#endif
+ /* FIXME: The CMU CL we forked off of had this Linux-only
+ * operation here. Newer CMU CLs (e.g. 18c) have hairier
+ * Linux/i386-only logic here. SBCL seems to be more reliable
+ * without anything here. However, if we start supporting code
+ * which sets the rounding mode, then we may want to do something
+ * special to force the rounding mode back to some standard value
+ * here, so that ISRs can have a standard environment. (OTOH, if
+ * rounding modes are under user control, then perhaps we should
+ * leave this up to the user.)
+ *
+ * In the absence of a test case to show that this is really a
+ * problem, we just suppress this code completely (just like the
+ * parallel code in maybe_now_maybe_later).
+ * #ifdef __linux__
+ * SET_FPU_CONTROL_WORD(context->__fpregs_mem.cw);
+ * #endif */
handler = interrupt_handlers[signal];
return;
}
- were_in_lisp = !foreign_function_call_active;
#ifndef __i386__
+ were_in_lisp = !foreign_function_call_active;
if (were_in_lisp)
#endif
{
}
#ifdef QSHOW_SIGNALS
- FSHOW((stderr, "in interrupt_handle_now(%d, info, context)\n", signal));
+ FSHOW((stderr,
+ "/entering interrupt_handle_now(%d, info, context)\n",
+ signal));
#endif
if (ARE_SAME_HANDLER(handler.c, SIG_DFL)) {
* support decides to pass on it. */
lose("no handler for signal %d in interrupt_handle_now(..)", signal);
- } else if (LowtagOf(handler.lisp) == type_FunctionPointer) {
+ } else if (LowtagOf(handler.lisp) == type_FunPointer) {
/* Allocate the SAPs while the interrupts are still disabled.
* (FIXME: Why? This is the way it was done in CMU CL, and it
* even had the comment noting that this is the way it was
* done, but no motivation..) */
- lispobj context_sap = alloc_sap(context);
- lispobj info_sap = alloc_sap(info);
-
+ lispobj info_sap,context_sap = alloc_sap(context);
+ info_sap = alloc_sap(info);
/* Allow signals again. */
sigprocmask(SIG_SETMASK, os_context_sigmask_addr(context), 0);
{
undo_fake_foreign_function_call(context);
}
+
+#ifdef QSHOW_SIGNALS
+ FSHOW((stderr,
+ "/returning from interrupt_handle_now(%d, info, context)\n",
+ signal));
+#endif
}
static void
/* FIXME: See Debian cmucl 2.4.17, and mail from DTC on the CMU CL
* mailing list 23 Oct 1999, for changes in FPU handling at
- * interrupt time which should be ported into SBCL.
+ * interrupt time which should be ported into SBCL. Also see the
+ * analogous logic at the head of interrupt_handle_now for
+ * more related FIXME stuff.
*
- * (Is this related to the way that it seems that if we do decide
- * to handle the interrupt later, we've now screwed up the FPU
- * control word?) */
-#ifdef __linux__
- SET_FPU_CONTROL_WORD(context->__fpregs_mem.cw);
-#endif
-
+ * For now, we just suppress this code completely.
+ * #ifdef __linux__
+ * SET_FPU_CONTROL_WORD(context->__fpregs_mem.cw);
+ * #endif */
+
+ /* see comments at top of code/signal.lisp for what's going on here
+ * with INTERRUPTS_ENABLED/INTERRUPT_HANDLE_NOW
+ */
if (SymbolValue(INTERRUPTS_ENABLED) == NIL) {
/* FIXME: This code is exactly the same as the code in the
os_context_sigmask_addr(context),
sizeof(sigset_t));
sigaddset_blockable(os_context_sigmask_addr(context));
-
SetSymbolValue(INTERRUPT_PENDING, T);
} else if (
context);
return (badaddr >= current_auto_gc_trigger &&
- badaddr < DYNAMIC_SPACE_START + DYNAMIC_SPACE_SIZE);
+ badaddr < current_dynamic_space + DYNAMIC_SPACE_SIZE);
}
}
#endif
#ifndef __i386__
+/* This function gets called from the SIGSEGV (for e.g. Linux or
+ * OpenBSD) or SIGBUS (for e.g. FreeBSD) handler. Here we check
+ * whether the signal was due to treading on the mprotect()ed zone -
+ * and if so, arrange for a GC to happen. */
boolean
-interrupt_maybe_gc(int signal, siginfo_t *info, os_context_t *context)
+interrupt_maybe_gc(int signal, siginfo_t *info, void *void_context)
{
+ os_context_t *context=(os_context_t *) void_context;
+
if (!foreign_function_call_active
#ifndef INTERNAL_GC_TRIGGER
&& gc_trigger_hit(signal, info, context)
#endif
if (arch_pseudo_atomic_atomic(context)) {
+ /* don't GC during an atomic operation. Instead, copy the
+ * signal mask somewhere safe. interrupt_handle_pending
+ * will detect pending_signal==0 and know to do a GC with the
+ * signal context instead of calling a Lisp-level handler */
maybe_gc_pending = 1;
if (pending_signal == 0) {
/* FIXME: This copy-pending_mask-then-sigaddset_blockable
* noise to install handlers
*/
-/* Install a special low-level handler for signal; or if handler is
- * SIG_DFL, remove any special handling for signal. */
+/*
+ * what low-level signal handlers looked like before
+ * undoably_install_low_level_interrupt_handler() got involved
+ */
+struct low_level_signal_handler_state {
+ int was_modified;
+ void (*handler)(int, siginfo_t*, void*);
+} old_low_level_signal_handler_states[NSIG];
+
+void
+uninstall_low_level_interrupt_handlers_atexit(void)
+{
+ int signal;
+ for (signal = 0; signal < NSIG; ++signal) {
+ struct low_level_signal_handler_state
+ *old_low_level_signal_handler_state =
+ old_low_level_signal_handler_states + signal;
+ if (old_low_level_signal_handler_state->was_modified) {
+ struct sigaction sa;
+ sa.sa_sigaction = old_low_level_signal_handler_state->handler;
+ sigemptyset(&sa.sa_mask);
+ sa.sa_flags = SA_SIGINFO | SA_RESTART;
+ sigaction(signal, &sa, NULL);
+ }
+ }
+}
+
+/* Undoably install a special low-level handler for signal; or if
+ * handler is SIG_DFL, remove any special handling for signal.
+ *
+ * The "undoably" aspect is because we also arrange with atexit() for
+ * the handler to be restored to its old value. This is for tidiness:
+ * it shouldn't matter much ordinarily, but it does remove a window
+ * where e.g. memory fault signals (SIGSEGV or SIGBUS, which in
+ * ordinary operation of SBCL are sent to the generational garbage
+ * collector, then possibly onward to Lisp code) or SIGINT (which is
+ * ordinarily passed to Lisp code) could otherwise be handled
+ * bizarrely/brokenly because the Lisp code would try to deal with
+ * them using machinery (like stream output buffers) which has already
+ * been dismantled. */
void
-interrupt_install_low_level_handler (int signal,
- void handler(int, siginfo_t*, void*))
+undoably_install_low_level_interrupt_handler (int signal,
+ void handler(int,
+ siginfo_t*,
+ void*))
{
struct sigaction sa;
+ struct low_level_signal_handler_state *old_low_level_signal_handler_state =
+ old_low_level_signal_handler_states + signal;
+
+ if (0 > signal || signal >= NSIG) {
+ lose("bad signal number %d", signal);
+ }
sa.sa_sigaction = handler;
sigemptyset(&sa.sa_mask);
sigaddset_blockable(&sa.sa_mask);
sa.sa_flags = SA_SIGINFO | SA_RESTART;
- sigaction(signal, &sa, NULL);
+ /* In the case of interrupt handlers which are modified more than
+ * once, we only save the original unmodified copy. */
+ if (!old_low_level_signal_handler_state->was_modified) {
+ struct sigaction *old_handler =
+ (struct sigaction*) &old_low_level_signal_handler_state->handler;
+ old_low_level_signal_handler_state->was_modified = 1;
+ sigaction(signal, &sa, old_handler);
+ } else {
+ sigaction(signal, &sa, NULL);
+ }
+
interrupt_low_level_handlers[signal] =
- (ARE_SAME_HANDLER(handler,SIG_DFL) ? 0 : handler);
+ (ARE_SAME_HANDLER(handler, SIG_DFL) ? 0 : handler);
}
/* This is called from Lisp. */
sigset_t old, new;
union interrupt_handler oldhandler;
- FSHOW((stderr, "entering POSIX install_handler(%d, ..)\n", signal));
+ FSHOW((stderr, "/entering POSIX install_handler(%d, ..)\n", signal));
sigemptyset(&new);
sigaddset(&new, signal);
sigemptyset(&new);
sigaddset_blockable(&new);
- FSHOW((stderr, "interrupt_low_level_handlers[signal]=%d\n",
+ FSHOW((stderr, "/interrupt_low_level_handlers[signal]=%d\n",
interrupt_low_level_handlers[signal]));
if (interrupt_low_level_handlers[signal]==0) {
if (ARE_SAME_HANDLER(handler, SIG_DFL) ||
sigprocmask(SIG_SETMASK, &old, 0);
- FSHOW((stderr, "leaving POSIX install_handler(%d, ..)\n", signal));
+ FSHOW((stderr, "/leaving POSIX install_handler(%d, ..)\n", signal));
return (unsigned long)oldhandler.lisp;
}
{
int i;
+ SHOW("entering interrupt_init()");
+
+ /* Set up for recovery from any installed low-level handlers. */
+ atexit(&uninstall_low_level_interrupt_handlers_atexit);
+
+ /* Set up high level handler information. */
for (i = 0; i < NSIG; i++) {
interrupt_handlers[i].c =
/* (The cast here blasts away the distinction between
* 3-argument form is expected.) */
(void (*)(int, siginfo_t*, void*))SIG_DFL;
}
+
+ SHOW("returning from interrupt_init()");
}
projects / sbcl.git / blobdiff