*/
#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 (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(..).
+ * 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];
== current_control_frame_pointer) {
/* 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) {
+ if (lowtagof(*os_context_register_addr(context, reg_CODE))
+ == FUN_POINTER_LOWTAG) {
/* We have called, but not built the new frame, so
* build it for them. */
current_control_frame_pointer[0] =
* 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
}
}
+/* 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)
{
}
}
- /* 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) {
}
#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) == FUN_POINTER_LOWTAG) {
/* 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
* 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