Menu
▾
▴
[Sbcl-commits] CVS: sbcl/src/runtime alloc.c,1.19,1.20 breakpoint.c,1.17,1.18 gencgc.c,1.67,1.68 hppa-arch.c,1.4,1.5 interrupt.c,1.74,1.75 interrupt.h,1.14,1.15 mips-arch.c,1.9,1.10 sparc-arch.c,1.12,1.13 x86-64-arch.c,1.4,1.5 x86-64-assem.S,1.5,1.6 x86-arch.c,1.28,1.29 x86-assem.S,1.20,1.21
|
From: <me...@us...> - 2005-06-08 08:50:03
|
Update of /cvsroot/sbcl/sbcl/src/runtime In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv10330/src/runtime Modified Files: alloc.c breakpoint.c gencgc.c hppa-arch.c interrupt.c interrupt.h mips-arch.c sparc-arch.c x86-64-arch.c x86-64-assem.S x86-arch.c x86-assem.S Log Message: 0.9.1.29: A number of signal handling cleanup/fixes: * fix gencgc/maybe_defer_handler race (thanks to Thiemo) * interrupt_maybe_gc (on cheneygc platforms): check for already pending handler before calling maybe_defer_handler in order not to lose interrupts * interrupt_handle_pending: check for the pending handler being null * run_deferred_handler: set the pending handler to null, before calling it to guard against the handler enabling interrupts ... * more defensiveness: enforce invariants: checks for signal masks, interrupts * refactoring: undoably_install_low_level_interrupt_handler wraps blockable handlers in low_level_maybe_now_maybe_later * don't unblock signals unconditionally in interrupt_maybe_gc_int just restore the sigmask from the interrupted context (kludge removed) * removed misguided sigprocmask calls from mips, hppa and sparc sig{trap,ill} handlers * removed non-x86 version of handle_breakpoint (interrupts are enabled in now common handle_breakpoint) * fixed arrange_return_to_lisp_function/post_signal_tramp to save and restore eflags (interrupt-threads seems to work) Index: alloc.c =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/runtime/alloc.c,v retrieving revision 1.19 retrieving revision 1.20 diff -u -d -r1.19 -r1.20 --- alloc.c 10 Aug 2004 00:20:46 -0000 1.19 +++ alloc.c 8 Jun 2005 08:49:52 -0000 1.20 @@ -45,11 +45,12 @@ { lispobj *result=0; struct thread *th=arch_os_get_current_thread(); + /* FIXME: OOAO violation: see arch_pseudo_* */ SetSymbolValue(PSEUDO_ATOMIC_INTERRUPTED, make_fixnum(0),th); SetSymbolValue(PSEUDO_ATOMIC_ATOMIC, make_fixnum(1),th); result=alloc(bytes); SetSymbolValue(PSEUDO_ATOMIC_ATOMIC, make_fixnum(0),th); - if (SymbolValue(PSEUDO_ATOMIC_INTERRUPTED,th)) + if (fixnum_value(SymbolValue(PSEUDO_ATOMIC_INTERRUPTED,th))) /* even if we gc at this point, the new allocation will be * protected from being moved, because result is on the c stack * and points to it */ Index: breakpoint.c =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/runtime/breakpoint.c,v retrieving revision 1.17 retrieving revision 1.18 diff -u -d -r1.17 -r1.18 --- breakpoint.c 1 Jun 2005 10:07:40 -0000 1.17 +++ breakpoint.c 8 Jun 2005 08:49:52 -0000 1.18 @@ -131,28 +131,7 @@ } } } -/* FIXME: I can see no really good reason these couldn't be merged, but haven't - * tried. The sigprocmask() call would work just as well on alpha as it - * presumably does on x86 -dan 2001.08.10 - */ -#if !(defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64)) -void handle_breakpoint(int signal, siginfo_t *info, os_context_t *context) -{ - lispobj code; - - fake_foreign_function_call(context); - - code = find_code(context); - /* FIXME we're calling into Lisp with signals masked here. Is this - * the right thing to do? */ - funcall3(SymbolFunction(HANDLE_BREAKPOINT), - compute_offset(context, code), - code, - alloc_sap(context)); - undo_fake_foreign_function_call(context); -} -#else void handle_breakpoint(int signal, siginfo_t* info, os_context_t *context) { lispobj code, context_sap = alloc_sap(context); @@ -172,7 +151,6 @@ undo_fake_foreign_function_call(context); } -#endif #if !(defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64)) void *handle_fun_end_breakpoint(int signal, siginfo_t *info, @@ -186,8 +164,10 @@ code = find_code(context); codeptr = (struct code *)native_pointer(code); - /* FIXME again, calling into Lisp with signals masked. Is this - * sensible? */ + /* Don't disallow recursive breakpoint traps. Otherwise, we can't + * use debugger breakpoints anywhere in here. */ + sigprocmask(SIG_SETMASK, os_context_sigmask_addr(context), 0); + funcall3(SymbolFunction(HANDLE_BREAKPOINT), compute_offset(context, code), code, Index: gencgc.c =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/runtime/gencgc.c,v retrieving revision 1.67 retrieving revision 1.68 diff -u -d -r1.67 -r1.68 --- gencgc.c 30 Apr 2005 18:20:58 -0000 1.67 +++ gencgc.c 8 Jun 2005 08:49:52 -0000 1.68 @@ -4147,9 +4147,20 @@ * already, in case it was a gc. If it wasn't a GC, the next * allocation will get us back to this point anyway, so no harm done */ + sigset_t new_mask,old_mask; + sigemptyset(&new_mask); + sigaddset_blockable(&new_mask); + sigprocmask(SIG_BLOCK,&new_mask,&old_mask); + struct interrupt_data *data=th->interrupt_data; - if(!data->pending_handler) - maybe_defer_handler(interrupt_maybe_gc_int,data,0,0,0); + if((!data->pending_handler) && + maybe_defer_handler(interrupt_maybe_gc_int,data,0,0,0)) { + /* Leave the signals blocked just as if it was deferred + * the normal way and set the pending_mask. */ + sigcopyset(&(data->pending_mask),&old_mask); + } else { + sigprocmask(SIG_SETMASK,&old_mask,0); + } } new_obj = gc_alloc_with_region(nbytes,0,region,0); return (new_obj); Index: hppa-arch.c =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/runtime/hppa-arch.c,v retrieving revision 1.4 retrieving revision 1.5 diff -u -d -r1.4 -r1.5 --- hppa-arch.c 10 Aug 2004 00:20:46 -0000 1.4 +++ hppa-arch.c 8 Jun 2005 08:49:52 -0000 1.5 @@ -181,7 +181,6 @@ os_context_t *context = arch_os_get_context(&void_context); unsigned long bad_inst; - sigprocmask(SIG_SETMASK, os_context_sigmask_addr(context), 0); #if 0 printf("sigtrap_handler, pc=0x%08x, alloc=0x%08x\n", scp->sc_pcoqh, SC_REG(scp,reg_ALLOC)); Index: interrupt.c =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/runtime/interrupt.c,v retrieving revision 1.74 retrieving revision 1.75 diff -u -d -r1.74 -r1.75 --- interrupt.c 29 May 2005 21:08:46 -0000 1.74 +++ interrupt.c 8 Jun 2005 08:49:52 -0000 1.75 @@ -75,17 +75,6 @@ extern volatile lispobj all_threads_lock; -/* - * This is a workaround for some slightly silly Linux/GNU Libc - * behaviour: glibc defines sigset_t to support 1024 signals, which is - * more than the kernel. This is usually not a problem, but becomes - * one when we want to save a signal mask from a ucontext, and restore - * it later into another ucontext: the ucontext is allocated on the - * stack by the kernel, so copying a libc-sized sigset_t into it will - * overflow and cause other data on the stack to be corrupted */ - -#define REAL_SIGSET_SIZE_BYTES ((NSIG/8)) - void sigaddset_blockable(sigset_t *s) { sigaddset(s, SIGHUP); @@ -111,6 +100,34 @@ #endif } +static sigset_t blockable_sigset; + +inline static void check_blockables_blocked_or_lose() +{ + /* Get the current sigmask, by blocking the empty set. */ + sigset_t empty,current; + sigemptyset(&empty); + sigprocmask(SIG_BLOCK, &empty, ¤t); + int i; + for(i=0;i<NSIG;i++) { + if (sigismember(&blockable_sigset, i) && !sigismember(¤t, i)) + lose("blockable signal %d not blocked",i); + } +} + +inline static void check_interrupts_enabled_or_lose(os_context_t *context) +{ + struct thread *thread=arch_os_get_current_thread(); + if (SymbolValue(INTERRUPTS_ENABLED,thread) == NIL) + lose("interrupts not enabled"); + if ( +#if !defined(LISP_FEATURE_X86) && !defined(LISP_FEATURE_X86_64) + (!foreign_function_call_active) && +#endif + arch_pseudo_atomic_atomic(context)) + lose ("in pseudo atomic section"); +} + /* When we catch an internal error, should we pass it back to Lisp to * be handled in a high-level way? (Early in cold init, the answer is * 'no', because Lisp is still too brain-dead to handle anything. @@ -195,6 +212,9 @@ int context_index; struct thread *thread=arch_os_get_current_thread(); + /* context_index incrementing must not be interrupted */ + check_blockables_blocked_or_lose(); + /* Get current Lisp state from context. */ #ifdef reg_ALLOC dynamic_space_free_pointer = @@ -265,6 +285,7 @@ { lispobj context_sap = 0; + check_blockables_blocked_or_lose(); fake_foreign_function_call(context); /* Allocate the SAP object while the interrupts are still @@ -303,26 +324,36 @@ struct thread *thread; struct interrupt_data *data; + check_blockables_blocked_or_lose(); + check_interrupts_enabled_or_lose(context); + thread=arch_os_get_current_thread(); data=thread->interrupt_data; - /* FIXME: This is almost certainly wrong if we're here as the - * result of a pseudo-atomic as opposed to WITHOUT-INTERRUPTS. */ - SetSymbolValue(INTERRUPT_PENDING, NIL,thread); + /* Pseudo atomic may trigger several times for a single interrupt, + * and while without-interrupts should not, a false trigger by + * pseudo-atomic may eat a pending handler even from + * without-interrupts. */ + if (data->pending_handler) { - /* restore the saved signal mask from the original signal (the - * one that interrupted us during the critical section) into the - * os_context for the signal we're currently in the handler for. - * This should ensure that when we return from the handler the - * blocked signals are unblocked */ + /* If we're here as the result of a pseudo-atomic as opposed + * to WITHOUT-INTERRUPTS, then INTERRUPT_PENDING is already + * NIL, because maybe_defer_handler sets + * PSEUDO_ATOMIC_INTERRUPTED only if interrupts are enabled.*/ + SetSymbolValue(INTERRUPT_PENDING, NIL,thread); - memcpy(os_context_sigmask_addr(context), &data->pending_mask, - REAL_SIGSET_SIZE_BYTES); + /* restore the saved signal mask from the original signal (the + * one that interrupted us during the critical section) into the + * os_context for the signal we're currently in the handler for. + * This should ensure that when we return from the handler the + * blocked signals are unblocked */ + sigcopyset(os_context_sigmask_addr(context), &data->pending_mask); - sigemptyset(&data->pending_mask); - /* This will break on sparc linux: the deferred handler really wants - * to be called with a void_context */ - run_deferred_handler(data,(void *)context); + sigemptyset(&data->pending_mask); + /* This will break on sparc linux: the deferred handler really wants + * to be called with a void_context */ + run_deferred_handler(data,(void *)context); + } } /* @@ -349,6 +380,8 @@ boolean were_in_lisp; #endif union interrupt_handler handler; + check_blockables_blocked_or_lose(); + check_interrupts_enabled_or_lose(context); #ifdef LISP_FEATURE_LINUX /* Under Linux on some architectures, we appear to have to restore @@ -443,9 +476,14 @@ void run_deferred_handler(struct interrupt_data *data, void *v_context) { - (*(data->pending_handler)) - (data->pending_signal,&(data->pending_info), v_context); + /* The pending_handler may enable interrupts (see + * interrupt_maybe_gc_int) and then another interrupt may hit, + * overwrite interrupt_data, so reset the pending handler before + * calling it. Trust the handler to finish with the siginfo before + * enabling interrupts. */ + void (*pending_handler) (int, siginfo_t*, void*)=data->pending_handler; data->pending_handler=0; + (*pending_handler)(data->pending_signal,&(data->pending_info), v_context); } boolean @@ -453,9 +491,23 @@ int signal, siginfo_t *info, os_context_t *context) { struct thread *thread=arch_os_get_current_thread(); + + check_blockables_blocked_or_lose(); + + if (SymbolValue(INTERRUPT_PENDING,thread) != NIL) + lose("interrupt already pending"); + /* If interrupts are disabled then INTERRUPT_PENDING is set and + * not PSEDUO_ATOMIC_INTERRUPTED. This is important for a pseudo + * atomic section inside a without-interrupts. + */ if (SymbolValue(INTERRUPTS_ENABLED,thread) == NIL) { store_signal_data_for_later(data,handler,signal,info,context); SetSymbolValue(INTERRUPT_PENDING, T,thread); +#ifdef QSHOW_SIGNALS + FSHOW((stderr, + "/maybe_defer_handler(%x,%d),thread=%d: deferred\n", + (unsigned int)handler,signal,thread->pid)); +#endif return 1; } /* a slightly confusing test. arch_pseudo_atomic_atomic() doesn't @@ -468,15 +520,31 @@ arch_pseudo_atomic_atomic(context)) { store_signal_data_for_later(data,handler,signal,info,context); arch_set_pseudo_atomic_interrupted(context); +#ifdef QSHOW_SIGNALS + FSHOW((stderr, + "/maybe_defer_handler(%x,%d),thread=%d: deferred(PA)\n", + (unsigned int)handler,signal,thread->pid)); +#endif return 1; } +#ifdef QSHOW_SIGNALS + FSHOW((stderr, + "/maybe_defer_handler(%x,%d),thread=%d: not deferred\n", + (unsigned int)handler,signal,thread->pid)); +#endif return 0; } + static void store_signal_data_for_later (struct interrupt_data *data, void *handler, int signal, siginfo_t *info, os_context_t *context) { + if (data->pending_handler) + lose("tried to overwrite pending interrupt handler %x with %x\n", + data->pending_handler, handler); + if (!handler) + lose("tried to defer null interrupt handler\n"); data->pending_handler = handler; data->pending_signal = signal; if(info) @@ -487,22 +555,11 @@ * run_deferred_handler happens. Then the usually-blocked * signals are added to the mask in the context so that we are * running with blocked signals when the handler returns */ - sigemptyset(&(data->pending_mask)); - memcpy(&(data->pending_mask), - os_context_sigmask_addr(context), - REAL_SIGSET_SIZE_BYTES); + sigcopyset(&(data->pending_mask),os_context_sigmask_addr(context)); sigaddset_blockable(os_context_sigmask_addr(context)); - } else { - /* this is also called from gencgc alloc(), in which case - * there has been no signal and is therefore no context. */ - sigset_t new; - sigemptyset(&new); - sigaddset_blockable(&new); - sigprocmask(SIG_BLOCK,&new,&(data->pending_mask)); } } - static void maybe_now_maybe_later(int signal, siginfo_t *info, void *void_context) { @@ -522,20 +579,53 @@ #endif } +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); +#ifdef LISP_FEATURE_DARWIN + /* Work around G5 bug */ + DARWIN_FIX_CONTEXT(context); +#endif +} + +static void +low_level_maybe_now_maybe_later(int signal, siginfo_t *info, void *void_context) +{ + os_context_t *context = arch_os_get_context(&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 + if(maybe_defer_handler(low_level_interrupt_handle_now,data, + signal,info,context)) + return; + low_level_interrupt_handle_now(signal, info, context); +#ifdef LISP_FEATURE_DARWIN + /* Work around G5 bug */ + DARWIN_FIX_CONTEXT(context); +#endif +} + #ifdef LISP_FEATURE_SB_THREAD void sig_stop_for_gc_handler(int signal, siginfo_t *info, void *void_context) { os_context_t *context = arch_os_get_context(&void_context); struct thread *thread=arch_os_get_current_thread(); - struct interrupt_data *data=thread->interrupt_data; sigset_t ss; int i; - if(maybe_defer_handler(sig_stop_for_gc_handler,data, - signal,info,context)) { - return; - } /* need the context stored so it can have registers scavenged */ fake_foreign_function_call(context); @@ -600,6 +690,10 @@ * previously */ +#if (defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64)) +int *context_eflags_addr(os_context_t *context); +#endif + extern lispobj call_into_lisp(lispobj fun, lispobj *args, int nargs); extern void post_signal_tramp(void); void arrange_return_to_lisp_function(os_context_t *context, lispobj function) @@ -611,6 +705,8 @@ /* Build a stack frame showing `interrupted' so that the * user's backtrace makes (as much) sense (as usual) */ + + /* FIXME: what about restoring fp state? */ #ifdef LISP_FEATURE_X86 /* Suppose the existence of some function that saved all * registers, called call_into_lisp, then restored GP registers and @@ -641,44 +737,47 @@ u32 *sp=(u32 *)*os_context_register_addr(context,reg_ESP); - *(sp-14) = post_signal_tramp; /* return address for call_into_lisp */ - *(sp-13) = function; /* args for call_into_lisp : function*/ - *(sp-12) = 0; /* arg array */ - *(sp-11) = 0; /* no. args */ + *(sp-15) = post_signal_tramp; /* return address for call_into_lisp */ + *(sp-14) = function; /* args for call_into_lisp : function*/ + *(sp-13) = 0; /* arg array */ + *(sp-12) = 0; /* no. args */ /* this order matches that used in POPAD */ - *(sp-10)=*os_context_register_addr(context,reg_EDI); - *(sp-9)=*os_context_register_addr(context,reg_ESI); + *(sp-11)=*os_context_register_addr(context,reg_EDI); + *(sp-10)=*os_context_register_addr(context,reg_ESI); - *(sp-8)=*os_context_register_addr(context,reg_ESP)-8; - *(sp-7)=0; - *(sp-6)=*os_context_register_addr(context,reg_EBX); + *(sp-9)=*os_context_register_addr(context,reg_ESP)-8; + /* POPAD ignores the value of ESP: */ + *(sp-8)=0; + *(sp-7)=*os_context_register_addr(context,reg_EBX); - *(sp-5)=*os_context_register_addr(context,reg_EDX); - *(sp-4)=*os_context_register_addr(context,reg_ECX); - *(sp-3)=*os_context_register_addr(context,reg_EAX); + *(sp-6)=*os_context_register_addr(context,reg_EDX); + *(sp-5)=*os_context_register_addr(context,reg_ECX); + *(sp-4)=*os_context_register_addr(context,reg_EAX); + *(sp-3)=*context_eflags_addr(context); *(sp-2)=*os_context_register_addr(context,reg_EBP); *(sp-1)=*os_context_pc_addr(context); #elif defined(LISP_FEATURE_X86_64) u64 *sp=(u64 *)*os_context_register_addr(context,reg_RSP); - *(sp-19) = post_signal_tramp; /* return address for call_into_lisp */ + *(sp-20) = post_signal_tramp; /* return address for call_into_lisp */ - *(sp-18)=*os_context_register_addr(context,reg_R15); - *(sp-17)=*os_context_register_addr(context,reg_R14); - *(sp-16)=*os_context_register_addr(context,reg_R13); - *(sp-15)=*os_context_register_addr(context,reg_R12); - *(sp-14)=*os_context_register_addr(context,reg_R11); - *(sp-13)=*os_context_register_addr(context,reg_R10); - *(sp-12)=*os_context_register_addr(context,reg_R9); - *(sp-11)=*os_context_register_addr(context,reg_R8); - *(sp-10)=*os_context_register_addr(context,reg_RDI); - *(sp-9)=*os_context_register_addr(context,reg_RSI); - *(sp-8)=*os_context_register_addr(context,reg_RSP)-16; - *(sp-7)=0; - *(sp-6)=*os_context_register_addr(context,reg_RBX); - *(sp-5)=*os_context_register_addr(context,reg_RDX); - *(sp-4)=*os_context_register_addr(context,reg_RCX); - *(sp-3)=*os_context_register_addr(context,reg_RAX); + *(sp-19)=*os_context_register_addr(context,reg_R15); + *(sp-18)=*os_context_register_addr(context,reg_R14); + *(sp-17)=*os_context_register_addr(context,reg_R13); + *(sp-16)=*os_context_register_addr(context,reg_R12); + *(sp-15)=*os_context_register_addr(context,reg_R11); + *(sp-14)=*os_context_register_addr(context,reg_R10); + *(sp-13)=*os_context_register_addr(context,reg_R9); + *(sp-12)=*os_context_register_addr(context,reg_R8); + *(sp-11)=*os_context_register_addr(context,reg_RDI); + *(sp-10)=*os_context_register_addr(context,reg_RSI); + *(sp-9)=*os_context_register_addr(context,reg_RSP)-16; + *(sp-8)=0; + *(sp-7)=*os_context_register_addr(context,reg_RBX); + *(sp-6)=*os_context_register_addr(context,reg_RDX); + *(sp-5)=*os_context_register_addr(context,reg_RCX); + *(sp-4)=*os_context_register_addr(context,reg_RAX); + *(sp-3)=*context_eflags_addr(context); *(sp-2)=*os_context_register_addr(context,reg_RBP); *(sp-1)=*os_context_pc_addr(context); @@ -695,15 +794,15 @@ *os_context_register_addr(context,reg_ECX) = 0; *os_context_register_addr(context,reg_EBP) = sp-2; #ifdef __NetBSD__ - *os_context_register_addr(context,reg_UESP) = sp-14; + *os_context_register_addr(context,reg_UESP) = sp-15; #else - *os_context_register_addr(context,reg_ESP) = sp-14; + *os_context_register_addr(context,reg_ESP) = sp-15; #endif #elif defined(LISP_FEATURE_X86_64) *os_context_pc_addr(context) = call_into_lisp; *os_context_register_addr(context,reg_RCX) = 0; *os_context_register_addr(context,reg_RBP) = sp-2; - *os_context_register_addr(context,reg_RSP) = sp-19; + *os_context_register_addr(context,reg_RSP) = sp-20; #else /* this much of the calling convention is common to all non-x86 ports */ @@ -727,12 +826,6 @@ void interrupt_thread_handler(int num, siginfo_t *info, void *v_context) { os_context_t *context = (os_context_t*)arch_os_get_context(&v_context); - struct thread *th=arch_os_get_current_thread(); - struct interrupt_data *data= - th ? th->interrupt_data : global_interrupt_data; - if(maybe_defer_handler(interrupt_thread_handler,data,num,info,context)){ - return ; - } arrange_return_to_lisp_function(context,info->si_value.sival_int); } @@ -805,71 +898,26 @@ struct interrupt_data *data= th ? th->interrupt_data : global_interrupt_data; - if(!foreign_function_call_active && gc_trigger_hit(signal, info, context)){ - clear_auto_gc_trigger(); - if(!maybe_defer_handler - (interrupt_maybe_gc_int,data,signal,info,void_context)) - interrupt_maybe_gc_int(signal,info,void_context); - return 1; + if(!data->pending_handler && !foreign_function_call_active && + gc_trigger_hit(signal, info, context)){ + clear_auto_gc_trigger(); + if(!maybe_defer_handler(interrupt_maybe_gc_int, + data,signal,info,void_context)) + interrupt_maybe_gc_int(signal,info,void_context); + return 1; } return 0; } #endif -void -kludge_sigset_for_gc(sigset_t * set) -{ -#ifndef LISP_FEATURE_GENCGC - /* FIXME: It is not sure if GENCGC is really right here: maybe this - * really affects eg. only Sparc and PPC. And the following KLUDGE - * could really use real fixing as well. - * - * KLUDGE: block some async signals that seem to have the ability - * to hang us in an uninterruptible state during GC -- at least - * part of the time. The main beneficiary of this is SB-SPROF, as - * SIGPROF was almost certain to be eventually triggered at a bad - * moment, rendering it virtually useless. SIGINT and SIGIO from - * user or eg. Slime also seemed to occasionally do this. - * - * The problem this papers over appears to be something going awry - * in SB-UNIX:RECEIVE-PENDING-SIGNALS at the end of the - * WITHOUT-INTERRUPTS in SUB-GC: adding debugging output shows us - * leaving the body of W-I, but never entering sigtrap_handler. - * - * Empirically, it seems that the problem is only triggered if the - * GC was triggered/deferred during a PA section, but this is not - * a sufficient condition: some collections triggered in such a - * manner seem to be able to receive and defer a signal during the - * GC without issues. Likewise empirically, it seems that the - * problem arises more often with floating point code then not. Eg - * (LOOP (* (RANDOM 1.0) (RANDOM 1.0))) will eventually hang if - * run with SB-SPROF on, but (LOOP (FOO (MAKE-LIST 24))) will not. - * All this makes some badnesss in the interaction between PA and - * W-I seem likely, possibly in the form of one or more bad VOPs. - * - * For additional entertainment on the affected platforms we - * currently use an actual illegal instruction to receive pending - * interrupts instead of a trap: whether this has any bearing on - * the matter is unknown. - * - * Apparently CMUCL blocks everything but SIGILL for GC on Sparc, - * possibly for this very reason. - * - * -- NS 2005-05-20 - */ - sigdelset(set, SIGPROF); - sigdelset(set, SIGIO); - sigdelset(set, SIGINT); -#endif -} - /* this is also used by gencgc, in alloc() */ boolean interrupt_maybe_gc_int(int signal, siginfo_t *info, void *void_context) { - sigset_t new; os_context_t *context=(os_context_t *) void_context; + + check_blockables_blocked_or_lose(); fake_foreign_function_call(context); /* SUB-GC may return without GCing if *GC-INHIBIT* is set, in @@ -881,11 +929,10 @@ * and signal a storage condition from there. */ - /* enable some signals before calling into Lisp */ - sigemptyset(&new); - sigaddset_blockable(&new); - kludge_sigset_for_gc(&new); - sigprocmask(SIG_UNBLOCK,&new,0); + /* restore the signal mask from the interrupted context before + * calling into Lisp */ + if (context) + sigprocmask(SIG_SETMASK, os_context_sigmask_addr(context), 0); funcall0(SymbolFunction(SUB_GC)); @@ -913,7 +960,11 @@ lose("bad signal number %d", signal); } - sa.sa_sigaction = handler; + if (sigismember(&blockable_sigset,signal)) + sa.sa_sigaction = low_level_maybe_now_maybe_later; + else + sa.sa_sigaction = handler; + sigemptyset(&sa.sa_mask); sigaddset_blockable(&sa.sa_mask); sa.sa_flags = SA_SIGINFO | SA_RESTART; @@ -951,8 +1002,8 @@ sigemptyset(&new); sigaddset_blockable(&new); - FSHOW((stderr, "/data->interrupt_low_level_handlers[signal]=%d\n", - data->interrupt_low_level_handlers[signal])); + 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) { if (ARE_SAME_HANDLER(handler, SIG_DFL) || ARE_SAME_HANDLER(handler, SIG_IGN)) { @@ -984,6 +1035,9 @@ { int i; SHOW("entering interrupt_init()"); + sigemptyset(&blockable_sigset); + sigaddset_blockable(&blockable_sigset); + global_interrupt_data=calloc(sizeof(struct interrupt_data), 1); /* Set up high level handler information. */ Index: interrupt.h =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/runtime/interrupt.h,v retrieving revision 1.14 retrieving revision 1.15 diff -u -d -r1.14 -r1.15 --- interrupt.h 14 Mar 2005 09:54:49 -0000 1.14 +++ interrupt.h 8 Jun 2005 08:49:52 -0000 1.15 @@ -14,6 +14,23 @@ #include <signal.h> +/* + * This is a workaround for some slightly silly Linux/GNU Libc + * behaviour: glibc defines sigset_t to support 1024 signals, which is + * more than the kernel. This is usually not a problem, but becomes + * one when we want to save a signal mask from a ucontext, and restore + * it later into another ucontext: the ucontext is allocated on the + * stack by the kernel, so copying a libc-sized sigset_t into it will + * overflow and cause other data on the stack to be corrupted */ +/* FIXME: do not rely on NSIG being a multiple of 8 */ +#define REAL_SIGSET_SIZE_BYTES ((NSIG/8)) + +static inline void +sigcopyset(sigset_t *new, sigset_t *old) +{ + memcpy(new, old, REAL_SIGSET_SIZE_BYTES); +} + /* maximum signal nesting depth * * Note: In CMU CL, this was 4096, but there was no explanation given, Index: mips-arch.c =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/runtime/mips-arch.c,v retrieving revision 1.9 retrieving revision 1.10 diff -u -d -r1.9 -r1.10 --- mips-arch.c 20 May 2005 09:45:15 -0000 1.9 +++ mips-arch.c 8 Jun 2005 08:49:52 -0000 1.10 @@ -229,14 +229,8 @@ sigtrap_handler(int signal, siginfo_t *info, void *void_context) { os_context_t *context = arch_os_get_context(&void_context); - sigset_t *mask; unsigned int code; - sigset_t ss; - /* Don't disallow recursive breakpoint traps. Otherwise, we can't - use debugger breakpoints anywhere in here. */ - mask = os_context_sigmask_addr(context); - sigprocmask(SIG_SETMASK, mask, NULL); code = ((*(int *) (*os_context_pc_addr(context))) >> 16) & 0x1f; switch (code) { @@ -246,9 +240,6 @@ case trap_PendingInterrupt: arch_skip_instruction(context); - sigemptyset(&ss); - sigaddset(&ss,SIGTRAP); - sigprocmask(SIG_UNBLOCK,&ss,0); interrupt_handle_pending(context); break; Index: sparc-arch.c =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/runtime/sparc-arch.c,v retrieving revision 1.12 retrieving revision 1.13 diff -u -d -r1.12 -r1.13 --- sparc-arch.c 9 Sep 2004 12:10:15 -0000 1.12 +++ sparc-arch.c 8 Jun 2005 08:49:52 -0000 1.13 @@ -188,7 +188,6 @@ /* FIXME: Check that this is necessary -- CSR, 2002-07-15 */ os_restore_fp_control(context); #endif - sigprocmask(SIG_SETMASK, os_context_sigmask_addr(context), 0); if ((siginfo->si_code) == ILL_ILLOPC #ifdef LISP_FEATURE_LINUX Index: x86-64-arch.c =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/runtime/x86-64-arch.c,v retrieving revision 1.4 retrieving revision 1.5 diff -u -d -r1.4 -r1.5 --- x86-64-arch.c 30 May 2005 05:25:45 -0000 1.4 +++ x86-64-arch.c 8 Jun 2005 08:49:52 -0000 1.5 @@ -192,7 +192,6 @@ int code = info->si_code; os_context_t *context = (os_context_t*)void_context; unsigned int trap; - sigset_t ss; if (single_stepping && (signal==SIGTRAP)) { @@ -243,9 +242,6 @@ case trap_PendingInterrupt: FSHOW((stderr, "/<trap pending interrupt>\n")); arch_skip_instruction(context); - sigemptyset(&ss); - sigaddset(&ss,SIGTRAP); - sigprocmask(SIG_UNBLOCK,&ss,0); interrupt_handle_pending(context); break; Index: x86-64-assem.S =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/runtime/x86-64-assem.S,v retrieving revision 1.5 retrieving revision 1.6 diff -u -d -r1.5 -r1.6 --- x86-64-assem.S 14 Apr 2005 22:34:45 -0000 1.5 +++ x86-64-assem.S 8 Jun 2005 08:49:52 -0000 1.6 @@ -334,6 +334,7 @@ popq %rbx popq %rcx popq %rax + popfl leave ret .size GNAME(post_signal_tramp),.-GNAME(post_signal_tramp) Index: x86-arch.c =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/runtime/x86-arch.c,v retrieving revision 1.28 retrieving revision 1.29 diff -u -d -r1.28 -r1.29 --- x86-arch.c 30 May 2005 05:25:45 -0000 1.28 +++ x86-arch.c 8 Jun 2005 08:49:52 -0000 1.29 @@ -193,7 +193,6 @@ int code = info->si_code; os_context_t *context = (os_context_t*)void_context; unsigned int trap; - sigset_t ss; if (single_stepping && (signal==SIGTRAP)) { @@ -244,10 +243,7 @@ case trap_PendingInterrupt: FSHOW((stderr, "/<trap pending interrupt>\n")); arch_skip_instruction(context); - sigemptyset(&ss); - sigaddset(&ss,SIGTRAP); - sigprocmask(SIG_UNBLOCK,&ss,0); - interrupt_handle_pending(context); + interrupt_handle_pending(context); break; case trap_Halt: Index: x86-assem.S =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/runtime/x86-assem.S,v retrieving revision 1.20 retrieving revision 1.21 diff -u -d -r1.20 -r1.21 --- x86-assem.S 1 Dec 2004 14:14:25 -0000 1.20 +++ x86-assem.S 8 Jun 2005 08:49:52 -0000 1.21 @@ -802,7 +802,8 @@ * doesn't exist. This is where call_into_lisp returns when called * using return_to_lisp_function */ addl $12,%esp /* clear call_into_lisp args from stack */ - popa /* restore registers */ + popal /* restore registers */ + popfl leave ret .size GNAME(post_signal_tramp),.-GNAME(post_signal_tramp) |