Steel Bank Common Lisp

Update of /cvsroot/sbcl/sbcl/src/runtime
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv12906/src/runtime

Modified Files:
	cheneygc.c gencgc.c interrupt.c interrupt.h purify.c thread.c 
Log Message:
0.9.4.14:
  * bug fix: interrupt handlers are now per-process to match
    pthread semantics, RUN-PROGRAM and SB-SPROF do not die
    with 'no handler for signal XX in interrupt_handle_now(..)'
    anymore


Index: cheneygc.c
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/runtime/cheneygc.c,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -d -r1.17 -r1.18
--- cheneygc.c	19 Aug 2005 22:21:02 -0000	1.17
+++ cheneygc.c	29 Aug 2005 14:30:46 -0000	1.18
@@ -124,8 +124,6 @@
     unsigned long control_stack_size, binding_stack_size;
     sigset_t tmp, old;
     struct thread *th=arch_os_get_current_thread();
-    struct interrupt_data *data=th->interrupt_data;
-
 
 #ifdef PRINTNOISE
     printf("[Collecting garbage ... \n");
@@ -177,8 +175,8 @@
     printf("Scavenging interrupt handlers (%d bytes) ...\n",
            (int)sizeof(interrupt_handlers));
 #endif
-    scavenge((lispobj *) data->interrupt_handlers,
-             sizeof(data->interrupt_handlers) / sizeof(lispobj));
+    scavenge((lispobj *) interrupt_handlers,
+             sizeof(interrupt_handlers) / sizeof(lispobj));
 
     /* _size quantities are in units of sizeof(lispobj) - i.e. 4 */
     control_stack_size =

Index: gencgc.c
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/runtime/gencgc.c,v
retrieving revision 1.80
retrieving revision 1.81
diff -u -d -r1.80 -r1.81
--- gencgc.c	26 Aug 2005 20:30:05 -0000	1.80
+++ gencgc.c	29 Aug 2005 14:30:46 -0000	1.81
@@ -3622,14 +3622,11 @@
 
     /* Scavenge the Lisp functions of the interrupt handlers, taking
      * care to avoid SIG_DFL and SIG_IGN. */
-    for_each_thread(th) {
-        struct interrupt_data *data=th->interrupt_data;
-        for (i = 0; i < NSIG; i++) {
-            union interrupt_handler handler = data->interrupt_handlers[i];
-            if (!ARE_SAME_HANDLER(handler.c, SIG_IGN) &&
-                !ARE_SAME_HANDLER(handler.c, SIG_DFL)) {
-                scavenge((lispobj *)(data->interrupt_handlers + i), 1);
-            }
+    for (i = 0; i < NSIG; i++) {
+        union interrupt_handler handler = interrupt_handlers[i];
+        if (!ARE_SAME_HANDLER(handler.c, SIG_IGN) &&
+            !ARE_SAME_HANDLER(handler.c, SIG_DFL)) {
+            scavenge((lispobj *)(interrupt_handlers + i), 1);
         }
     }
     /* Scavenge the function list for INTERRUPT-THREAD. */

Index: interrupt.c
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/runtime/interrupt.c,v
retrieving revision 1.90
retrieving revision 1.91
diff -u -d -r1.90 -r1.91
--- interrupt.c	26 Aug 2005 19:33:47 -0000	1.90
+++ interrupt.c	29 Aug 2005 14:30:46 -0000	1.91
@@ -143,7 +143,8 @@
  * 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
@@ -416,7 +417,6 @@
 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
@@ -431,7 +431,7 @@
        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;
@@ -467,7 +467,10 @@
          * 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);
@@ -618,16 +621,13 @@
 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();
-    struct interrupt_data *data=thread->interrupt_data;
 
 #ifdef LISP_FEATURE_LINUX
     os_restore_fp_control(context);
 #endif
     check_blockables_blocked_or_lose();
     check_interrupts_enabled_or_lose(context);
-    (*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);
@@ -1051,10 +1051,6 @@
                                                            void*))
 {
     struct sigaction sa;
-    struct thread *th=arch_os_get_current_thread();
-    /* It may be before the initial thread is started. */
-    struct interrupt_data *data=
-        th ? th->interrupt_data : global_interrupt_data;
 
     if (0 > signal || signal >= NSIG) {
         lose("bad signal number %d", signal);
@@ -1078,7 +1074,7 @@
 #endif
 
     sigaction(signal, &sa, NULL);
-    data->interrupt_low_level_handlers[signal] =
+    interrupt_low_level_handlers[signal] =
         (ARE_SAME_HANDLER(handler, SIG_DFL) ? 0 : handler);
 }
 
@@ -1089,10 +1085,6 @@
     struct sigaction sa;
     sigset_t old, new;
     union interrupt_handler oldhandler;
-    struct thread *th=arch_os_get_current_thread();
-    /* It may be before the initial thread is started. */
-    struct interrupt_data *data=
-        th ? th->interrupt_data : global_interrupt_data;
 
     FSHOW((stderr, "/entering POSIX install_handler(%d, ..)\n", signal));
 
@@ -1100,9 +1092,9 @@
     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;
@@ -1118,8 +1110,8 @@
         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);
 
@@ -1138,11 +1130,9 @@
     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

Index: interrupt.h
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/runtime/interrupt.h,v
retrieving revision 1.22
retrieving revision 1.23
diff -u -d -r1.22 -r1.23
--- interrupt.h	26 Aug 2005 19:13:02 -0000	1.22
+++ interrupt.h	29 Aug 2005 14:30:46 -0000	1.23
@@ -45,10 +45,9 @@
     void (*c)(int, siginfo_t*, void*);
 };
 
-struct interrupt_data {
-    void (*interrupt_low_level_handlers[NSIG]) (int, siginfo_t*, void*) ;
-    union interrupt_handler interrupt_handlers[NSIG];
+extern union interrupt_handler interrupt_handlers[NSIG];
 
+struct interrupt_data {
     /* signal information for pending signal.  pending_signal=0 when there
      * is no pending signal. */
     void (*pending_handler) (int, siginfo_t*, void*) ;

Index: purify.c
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/runtime/purify.c,v
retrieving revision 1.54
retrieving revision 1.55
diff -u -d -r1.54 -r1.55
--- purify.c	4 Aug 2005 12:48:21 -0000	1.54
+++ purify.c	29 Aug 2005 14:30:46 -0000	1.55
@@ -1491,9 +1491,8 @@
     printf(" handlers");
     fflush(stdout);
 #endif
-    pscav((lispobj *) all_threads->interrupt_data->interrupt_handlers,
-          sizeof(all_threads->interrupt_data->interrupt_handlers)
-          / sizeof(lispobj),
+    pscav((lispobj *) interrupt_handlers,
+          sizeof(interrupt_handlers) / sizeof(lispobj),
           0);
 
 #ifdef PRINTNOISE

Index: thread.c
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/runtime/thread.c,v
retrieving revision 1.52
retrieving revision 1.53
diff -u -d -r1.52 -r1.53
--- thread.c	26 Aug 2005 22:16:47 -0000	1.52
+++ thread.c	29 Aug 2005 14:30:46 -0000	1.53
@@ -262,14 +262,7 @@
         free_thread_struct(th);
         return 0;
     }
-    if(all_threads)
-        memcpy(th->interrupt_data,
-               arch_os_get_current_thread()->interrupt_data,
-               sizeof (struct interrupt_data));
-    else
-        memcpy(th->interrupt_data,global_interrupt_data,
-               sizeof (struct interrupt_data));
-
+    th->interrupt_data->pending_handler = 0;
     th->no_tls_value_marker=initial_function;
     return th;
 }