X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Finterrupt.c;h=2be4af4b639148e0fa7d460ddedbf28b92a83fad;hb=85483d976cc2d779493985f77f39efefb2ea622b;hp=d711858468ccd6ae559c0be39565a2b486fe3958;hpb=47eb330ef0f3b99d24c0e24d897b757f16950c4b;p=sbcl.git

diff --git a/src/runtime/interrupt.c b/src/runtime/interrupt.c
index d711858..2be4af4 100644
--- a/src/runtime/interrupt.c
+++ b/src/runtime/interrupt.c
@@ -83,7 +83,6 @@ void sigaddset_deferrable(sigset_t *s)
     sigaddset(s, SIGPIPE);
     sigaddset(s, SIGALRM);
     sigaddset(s, SIGURG);
-    sigaddset(s, SIGFPE);
     sigaddset(s, SIGTSTP);
     sigaddset(s, SIGCHLD);
     sigaddset(s, SIGIO);
@@ -144,34 +143,24 @@ inline static void check_interrupts_enabled_or_lose(os_context_t *context)
  * becomes 'yes'.) */
 boolean internal_errors_enabled = 0;
 
-struct interrupt_data * global_interrupt_data;
+static void (*interrupt_low_level_handlers[NSIG]) (int, siginfo_t*, void*);
+union interrupt_handler interrupt_handlers[NSIG];
 
 /* At the toplevel repl we routinely call this function.  The signal
  * mask ought to be clear anyway most of the time, but may be non-zero
  * if we were interrupted e.g. while waiting for a queue.  */
 
-void reset_signal_mask ()
+void reset_signal_mask(void)
 {
     sigset_t new;
     sigemptyset(&new);
     thread_sigmask(SIG_SETMASK,&new,0);
 }
 
-void block_deferrable_signals_and_inhibit_gc ()
+void block_blockable_signals(void)
 {
-    struct thread *thread=arch_os_get_current_thread();
     sigset_t block;
-    sigemptyset(&block);
-    sigaddset_deferrable(&block);
-    thread_sigmask(SIG_BLOCK, &block, 0);
-    bind_variable(GC_INHIBIT,T,thread);
-}
-
-static void block_blockable_signals ()
-{
-    sigset_t block;
-    sigemptyset(&block);
-    sigaddset_blockable(&block);
+    sigcopyset(&block, &blockable_sigset);
     thread_sigmask(SIG_BLOCK, &block, 0);
 }
 
@@ -180,7 +169,7 @@ static void block_blockable_signals ()
  * utility routines used by various signal handlers
  */
 
-void
+static void
 build_fake_control_stack_frames(struct thread *th,os_context_t *context)
 {
 #ifndef LISP_FEATURE_C_STACK_IS_CONTROL_STACK
@@ -190,8 +179,10 @@ build_fake_control_stack_frames(struct thread *th,os_context_t *context)
     /* Build a fake stack frame or frames */
 
     current_control_frame_pointer =
-        (lispobj *)(*os_context_register_addr(context, reg_CSP));
-    if ((lispobj *)(*os_context_register_addr(context, reg_CFP))
+        (lispobj *)(unsigned long)
+            (*os_context_register_addr(context, reg_CSP));
+    if ((lispobj *)(unsigned long)
+            (*os_context_register_addr(context, reg_CFP))
         == current_control_frame_pointer) {
         /* There is a small window during call where the callee's
          * frame isn't built yet. */
@@ -243,7 +234,8 @@ fake_foreign_function_call(os_context_t *context)
     /* Get current Lisp state from context. */
 #ifdef reg_ALLOC
     dynamic_space_free_pointer =
-        (lispobj *)(*os_context_register_addr(context, reg_ALLOC));
+        (lispobj *)(unsigned long)
+            (*os_context_register_addr(context, reg_ALLOC));
 #if defined(LISP_FEATURE_ALPHA)
     if ((long)dynamic_space_free_pointer & 1) {
         lose("dead in fake_foreign_function_call, context = %x", context);
@@ -252,7 +244,8 @@ fake_foreign_function_call(os_context_t *context)
 #endif
 #ifdef reg_BSP
     current_binding_stack_pointer =
-        (lispobj *)(*os_context_register_addr(context, reg_BSP));
+        (lispobj *)(unsigned long)
+            (*os_context_register_addr(context, reg_BSP));
 #endif
 
     build_fake_control_stack_frames(thread,context);
@@ -307,33 +300,31 @@ interrupt_internal_error(int signal, siginfo_t *info, os_context_t *context,
 {
     lispobj context_sap = 0;
 
-    check_blockables_blocked_or_lose();
     fake_foreign_function_call(context);
 
+    if (!internal_errors_enabled) {
+        describe_internal_error(context);
+        /* There's no good way to recover from an internal error
+         * before the Lisp error handling mechanism is set up. */
+        lose("internal error too early in init, can't recover");
+    }
+
     /* Allocate the SAP object while the interrupts are still
      * disabled. */
-    if (internal_errors_enabled) {
-        context_sap = alloc_sap(context);
-    }
+    context_sap = alloc_sap(context);
 
     thread_sigmask(SIG_SETMASK, os_context_sigmask_addr(context), 0);
 
-    if (internal_errors_enabled) {
-        SHOW("in interrupt_internal_error");
+    SHOW("in interrupt_internal_error");
 #ifdef QSHOW
-        /* Display some rudimentary debugging information about the
-         * error, so that even if the Lisp error handler gets badly
-         * confused, we have a chance to determine what's going on. */
-        describe_internal_error(context);
+    /* Display some rudimentary debugging information about the
+     * error, so that even if the Lisp error handler gets badly
+     * confused, we have a chance to determine what's going on. */
+    describe_internal_error(context);
 #endif
-        funcall2(SymbolFunction(INTERNAL_ERROR), context_sap,
-                 continuable ? T : NIL);
-    } else {
-        describe_internal_error(context);
-        /* There's no good way to recover from an internal error
-         * before the Lisp error handling mechanism is set up. */
-        lose("internal error too early in init, can't recover");
-    }
+    funcall2(SymbolFunction(INTERNAL_ERROR), context_sap,
+             continuable ? T : NIL);
+
     undo_fake_foreign_function_call(context); /* blocks signals again */
     if (continuable) {
         arch_skip_instruction(context);
@@ -427,13 +418,13 @@ void
 interrupt_handle_now(int signal, siginfo_t *info, void *void_context)
 {
     os_context_t *context = (os_context_t*)void_context;
-    struct thread *thread=arch_os_get_current_thread();
 #if !defined(LISP_FEATURE_X86) && !defined(LISP_FEATURE_X86_64)
     boolean were_in_lisp;
 #endif
     union interrupt_handler handler;
     check_blockables_blocked_or_lose();
-    check_interrupts_enabled_or_lose(context);
+    if (sigismember(&deferrable_sigset,signal))
+        check_interrupts_enabled_or_lose(context);
 
 #ifdef LISP_FEATURE_LINUX
     /* Under Linux on some architectures, we appear to have to restore
@@ -441,7 +432,7 @@ interrupt_handle_now(int signal, siginfo_t *info, void *void_context)
        delivered we appear to have a null FPU control word. */
     os_restore_fp_control(context);
 #endif
-    handler = thread->interrupt_data->interrupt_handlers[signal];
+    handler = interrupt_handlers[signal];
 
     if (ARE_SAME_HANDLER(handler.c, SIG_IGN)) {
         return;
@@ -477,7 +468,10 @@ interrupt_handle_now(int signal, siginfo_t *info, void *void_context)
          * because we're not in pseudoatomic and allocation shouldn't
          * be interrupted.  In which case it's no longer an issue as
          * all our allocation from C now goes through a PA wrapper,
-         * but still, doesn't hurt */
+         * but still, doesn't hurt.
+         *
+         * Yeah, but non-gencgc platforms that don't really wrap
+         * allocation in PA. MG - 2005-08-29  */
 
         lispobj info_sap,context_sap = alloc_sap(context);
         info_sap = alloc_sap(info);
@@ -615,8 +609,7 @@ maybe_now_maybe_later(int signal, siginfo_t *info, void *void_context)
 #ifdef LISP_FEATURE_LINUX
     os_restore_fp_control(context);
 #endif
-    if(maybe_defer_handler(interrupt_handle_now,data,
-                           signal,info,context))
+    if(maybe_defer_handler(interrupt_handle_now,data,signal,info,context))
         return;
     interrupt_handle_now(signal, info, context);
 #ifdef LISP_FEATURE_DARWIN
@@ -629,15 +622,13 @@ static void
 low_level_interrupt_handle_now(int signal, siginfo_t *info, void *void_context)
 {
     os_context_t *context = (os_context_t*)void_context;
-    struct thread *thread=arch_os_get_current_thread();
 
 #ifdef LISP_FEATURE_LINUX
     os_restore_fp_control(context);
 #endif
     check_blockables_blocked_or_lose();
     check_interrupts_enabled_or_lose(context);
-    (*thread->interrupt_data->interrupt_low_level_handlers[signal])
-        (signal, info, void_context);
+    interrupt_low_level_handlers[signal](signal, info, void_context);
 #ifdef LISP_FEATURE_DARWIN
     /* Work around G5 bug */
     DARWIN_FIX_CONTEXT(context);
@@ -684,8 +675,7 @@ sig_stop_for_gc_handler(int signal, siginfo_t *info, void *void_context)
         /* need the context stored so it can have registers scavenged */
         fake_foreign_function_call(context);
 
-        sigemptyset(&ss);
-        for(i=1;i<NSIG;i++) sigaddset(&ss,i); /* Block everything. */
+        sigfillset(&ss); /* Block everything. */
         thread_sigmask(SIG_BLOCK,&ss,0);
 
         /* The GC can't tell if a thread is a zombie, so this would be a
@@ -868,11 +858,12 @@ void arrange_return_to_lisp_function(os_context_t *context, lispobj function)
 #else
     /* this much of the calling convention is common to all
        non-x86 ports */
-    *os_context_pc_addr(context) = (os_context_register_t)code;
+    *os_context_pc_addr(context) = (os_context_register_t)(unsigned long)code;
     *os_context_register_addr(context,reg_NARGS) = 0;
-    *os_context_register_addr(context,reg_LIP) = (os_context_register_t)code;
+    *os_context_register_addr(context,reg_LIP) =
+        (os_context_register_t)(unsigned long)code;
     *os_context_register_addr(context,reg_CFP) =
-        (os_context_register_t)current_control_frame_pointer;
+        (os_context_register_t)(unsigned long)current_control_frame_pointer;
 #endif
 #ifdef ARCH_HAS_NPC_REGISTER
     *os_context_npc_addr(context) =
@@ -897,14 +888,18 @@ void interrupt_thread_handler(int num, siginfo_t *info, void *v_context)
      * thread interrupt execution is undefined. */
     struct thread *th=arch_os_get_current_thread();
     struct cons *c;
+    lispobj function;
     if (th->state != STATE_RUNNING)
-        lose("interrupt_thread_handler: thread %ld in wrong state: %d\n",
+        lose("interrupt_thread_handler: thread %lu in wrong state: %d\n",
              th->os_thread,fixnum_value(th->state));
     get_spinlock(&th->interrupt_fun_lock,(long)th);
     c=((struct cons *)native_pointer(th->interrupt_fun));
-    arrange_return_to_lisp_function(context,c->car);
+    function=c->car;
     th->interrupt_fun=c->cdr;
     release_spinlock(&th->interrupt_fun_lock);
+    if (function==NIL)
+        lose("interrupt_thread_handler: NIL function\n");
+    arrange_return_to_lisp_function(context,function);
 }
 
 #endif
@@ -968,9 +963,6 @@ boolean
 interrupt_maybe_gc(int signal, siginfo_t *info, void *void_context)
 {
     os_context_t *context=(os_context_t *) void_context;
-    struct thread *th=arch_os_get_current_thread();
-    struct interrupt_data *data=
-        th ? th->interrupt_data : global_interrupt_data;
 
     if(!foreign_function_call_active && gc_trigger_hit(signal, info, context)){
         struct thread *thread=arch_os_get_current_thread();
@@ -1006,7 +998,6 @@ interrupt_maybe_gc_int(int signal, siginfo_t *info, void *void_context)
     os_context_t *context=(os_context_t *) void_context;
     struct thread *thread=arch_os_get_current_thread();
 
-    check_blockables_blocked_or_lose();
     fake_foreign_function_call(context);
 
     /* SUB-GC may return without GCing if *GC-INHIBIT* is set, in
@@ -1058,9 +1049,6 @@ undoably_install_low_level_interrupt_handler (int signal,
                                                            void*))
 {
     struct sigaction sa;
-    struct thread *th=arch_os_get_current_thread();
-    struct interrupt_data *data=
-        th ? th->interrupt_data : global_interrupt_data;
 
     if (0 > signal || signal >= NSIG) {
         lose("bad signal number %d", signal);
@@ -1071,8 +1059,7 @@ undoably_install_low_level_interrupt_handler (int signal,
     else
         sa.sa_sigaction = handler;
 
-    sigemptyset(&sa.sa_mask);
-    sigaddset_blockable(&sa.sa_mask);
+    sigcopyset(&sa.sa_mask, &blockable_sigset);
     sa.sa_flags = SA_SIGINFO | SA_RESTART;
 #ifdef LISP_FEATURE_C_STACK_IS_CONTROL_STACK
     if((signal==SIG_MEMORY_FAULT)
@@ -1080,11 +1067,11 @@ undoably_install_low_level_interrupt_handler (int signal,
        || (signal==SIG_INTERRUPT_THREAD)
 #endif
        )
-        sa.sa_flags|= SA_ONSTACK;
+        sa.sa_flags |= SA_ONSTACK;
 #endif
 
     sigaction(signal, &sa, NULL);
-    data->interrupt_low_level_handlers[signal] =
+    interrupt_low_level_handlers[signal] =
         (ARE_SAME_HANDLER(handler, SIG_DFL) ? 0 : handler);
 }
 
@@ -1095,9 +1082,6 @@ install_handler(int signal, void handler(int, siginfo_t*, void*))
     struct sigaction sa;
     sigset_t old, new;
     union interrupt_handler oldhandler;
-    struct thread *th=arch_os_get_current_thread();
-    struct interrupt_data *data=
-        th ? th->interrupt_data : global_interrupt_data;
 
     FSHOW((stderr, "/entering POSIX install_handler(%d, ..)\n", signal));
 
@@ -1105,9 +1089,9 @@ install_handler(int signal, void handler(int, siginfo_t*, void*))
     sigaddset(&new, signal);
     thread_sigmask(SIG_BLOCK, &new, &old);
 
-    FSHOW((stderr, "/data->interrupt_low_level_handlers[signal]=%x\n",
-           (unsigned int)data->interrupt_low_level_handlers[signal]));
-    if (data->interrupt_low_level_handlers[signal]==0) {
+    FSHOW((stderr, "/interrupt_low_level_handlers[signal]=%x\n",
+           (unsigned int)interrupt_low_level_handlers[signal]));
+    if (interrupt_low_level_handlers[signal]==0) {
         if (ARE_SAME_HANDLER(handler, SIG_DFL) ||
             ARE_SAME_HANDLER(handler, SIG_IGN)) {
             sa.sa_sigaction = handler;
@@ -1117,14 +1101,13 @@ install_handler(int signal, void handler(int, siginfo_t*, void*))
             sa.sa_sigaction = interrupt_handle_now_handler;
         }
 
-        sigemptyset(&sa.sa_mask);
-        sigaddset_blockable(&sa.sa_mask);
+        sigcopyset(&sa.sa_mask, &blockable_sigset);
         sa.sa_flags = SA_SIGINFO | SA_RESTART;
         sigaction(signal, &sa, NULL);
     }
 
-    oldhandler = data->interrupt_handlers[signal];
-    data->interrupt_handlers[signal].c = handler;
+    oldhandler = interrupt_handlers[signal];
+    interrupt_handlers[signal].c = handler;
 
     thread_sigmask(SIG_SETMASK, &old, 0);
 
@@ -1143,11 +1126,9 @@ interrupt_init()
     sigaddset_deferrable(&deferrable_sigset);
     sigaddset_blockable(&blockable_sigset);
 
-    global_interrupt_data=calloc(sizeof(struct interrupt_data), 1);
-
     /* Set up high level handler information. */
     for (i = 0; i < NSIG; i++) {
-        global_interrupt_data->interrupt_handlers[i].c =
+        interrupt_handlers[i].c =
             /* (The cast here blasts away the distinction between
              * SA_SIGACTION-style three-argument handlers and
              * signal(..)-style one-argument handlers, which is OK