#include <stdlib.h>
#include <string.h>
#include <signal.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include "sbcl.h"
#include "runtime.h"
#include "arch.h"
-#include "sbcl.h"
#include "os.h"
#include "interrupt.h"
#include "globals.h"
#include "genesis/fdefn.h"
#include "genesis/simple-fun.h"
+
+
void run_deferred_handler(struct interrupt_data *data, void *v_context) ;
static void store_signal_data_for_later (struct interrupt_data *data,
void *handler, int signal,
os_context_t *context);
boolean interrupt_maybe_gc_int(int signal, siginfo_t *info, void *v_context);
-extern lispobj all_threads_lock;
-extern int countdown_to_gc;
+extern volatile lispobj all_threads_lock;
/*
* This is a workaround for some slightly silly Linux/GNU Libc
sigaddset(s, SIGUSR1);
sigaddset(s, SIGUSR2);
#ifdef LISP_FEATURE_SB_THREAD
- /* don't block STOP_FOR_GC, we need to be able to interrupt threads
- * for GC purposes even when they are blocked on queues etc */
+ sigaddset(s, SIG_STOP_FOR_GC);
sigaddset(s, SIG_INTERRUPT_THREAD);
+ sigaddset(s, SIG_THREAD_EXIT);
#endif
}
struct interrupt_data * global_interrupt_data;
+/* 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. */
+
+#if 1
+void reset_signal_mask ()
+{
+ sigset_t new;
+ sigemptyset(&new);
+ sigprocmask(SIG_SETMASK,&new,0);
+}
+#else
+void reset_signal_mask ()
+{
+ sigset_t new,old;
+ int i;
+ int wrong=0;
+ sigemptyset(&new);
+ sigprocmask(SIG_SETMASK,&new,&old);
+ for(i=1; i<NSIG; i++) {
+ if(sigismember(&old,i)) {
+ fprintf(stderr,
+ "Warning: signal %d is masked: this is unexpected\n",i);
+ wrong=1;
+ }
+ }
+ if(wrong)
+ fprintf(stderr,"If this version of SBCL is less than three months old, please report this.\nOtherwise, please try a newer version first\n. Reset signal mask.\n");
+}
+#endif
+
+
+
\f
/*
* utility routines used by various signal handlers
* before the Lisp error handling mechanism is set up. */
lose("internal error too early in init, can't recover");
}
- undo_fake_foreign_function_call(context);
+ undo_fake_foreign_function_call(context); /* blocks signals again */
if (continuable) {
arch_skip_instruction(context);
}
thread=arch_os_get_current_thread();
data=thread->interrupt_data;
+ /* FIXME I'm not altogether sure this is appropriate if we're
+ * here as the result of a pseudo-atomic */
SetSymbolValue(INTERRUPT_PENDING, NIL,thread);
/* restore the saved signal mask from the original signal (the
{
os_context_t *context = (os_context_t*)void_context;
struct thread *thread=arch_os_get_current_thread();
-#ifndef __i386__
+#ifndef LISP_FEATURE_X86
boolean were_in_lisp;
#endif
union interrupt_handler handler;
return;
}
-#ifndef __i386__
+#ifndef LISP_FEATURE_X86
were_in_lisp = !foreign_function_call_active;
if (were_in_lisp)
#endif
(*handler.c)(signal, info, void_context);
}
-#ifndef __i386__
+#ifndef LISP_FEATURE_X86
if (were_in_lisp)
#endif
{
- undo_fake_foreign_function_call(context);
+ undo_fake_foreign_function_call(context); /* block signals again */
}
#ifdef QSHOW_SIGNALS
run_deferred_handler(struct interrupt_data *data, void *v_context) {
(*(data->pending_handler))
(data->pending_signal,&(data->pending_info), v_context);
+ data->pending_handler=0;
}
boolean
* actually use its argument for anything on x86, so this branch
* may succeed even when context is null (gencgc alloc()) */
if (
-#ifndef __i386__
+#ifndef LISP_FEATURE_X86
(!foreign_function_call_active) &&
#endif
arch_pseudo_atomic_atomic(context)) {
signal,info,context))
return;
interrupt_handle_now(signal, info, context);
+#ifdef LISP_FEATURE_DARWIN
+ /* Work around G5 bug */
+ sigreturn(void_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 block;
-
+ sigset_t ss;
+ int i;
+
if(maybe_defer_handler(sig_stop_for_gc_handler,data,
- signal,info,context)){
+ signal,info,context)) {
return;
}
- sigemptyset(&block);
- sigaddset_blockable(&block);
- sigprocmask(SIG_BLOCK, &block, 0);
- get_spinlock(&all_threads_lock,thread->pid);
- countdown_to_gc--;
- release_spinlock(&all_threads_lock);
/* need the context stored so it can have registers scavenged */
fake_foreign_function_call(context);
- kill(getpid(),SIGSTOP);
+
+ sigemptyset(&ss);
+ for(i=1;i<NSIG;i++) sigaddset(&ss,i); /* Block everything. */
+ sigprocmask(SIG_BLOCK,&ss,0);
+
+ get_spinlock(&all_threads_lock,thread->pid);
+ thread->state=STATE_STOPPED;
+ release_spinlock(&all_threads_lock);
+
+ sigemptyset(&ss); sigaddset(&ss,SIG_STOP_FOR_GC);
+ sigwaitinfo(&ss,0);
+
undo_fake_foreign_function_call(context);
}
+#endif
void
interrupt_handle_now_handler(int signal, siginfo_t *info, void *void_context)
{
os_context_t *context = arch_os_get_context(&void_context);
interrupt_handle_now(signal, info, context);
+#ifdef LISP_FEATURE_DARWIN
+ sigreturn(void_context);
+#endif
}
/*
extern void post_signal_tramp(void);
void arrange_return_to_lisp_function(os_context_t *context, lispobj function)
{
+#ifndef LISP_FEATURE_X86
void * fun=native_pointer(function);
- char *code = &(((struct simple_fun *) fun)->code);
-
+ void *code = &(((struct simple_fun *) fun)->code);
+#endif
+
/* Build a stack frame showing `interrupted' so that the
* user's backtrace makes (as much) sense (as usual) */
#ifdef LISP_FEATURE_X86
}
#ifdef LISP_FEATURE_SB_THREAD
-void handle_rt_signal(int num, siginfo_t *info, void *v_context)
+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(handle_rt_signal,data,num,info,context)){
+ if(maybe_defer_handler(interrupt_thread_handler,data,num,info,context)){
return ;
}
arrange_return_to_lisp_function(context,info->si_value.sival_int);
}
+
+void thread_exit_handler(int num, siginfo_t *info, void *v_context)
+{ /* called when a child thread exits */
+ os_context_t *context = (os_context_t*)arch_os_get_context(&v_context);
+ struct thread *th=arch_os_get_current_thread();
+ pid_t kid;
+ int *status;
+ struct interrupt_data *data=
+ th ? th->interrupt_data : global_interrupt_data;
+ if(maybe_defer_handler(thread_exit_handler,data,num,info,context)){
+ return ;
+ }
+ while(1) {
+ kid=waitpid(-1,&status,__WALL|WNOHANG);
+ if(kid<1) break;
+ if(WIFEXITED(status) || WIFSIGNALED(status)) {
+ struct thread *th=find_thread_by_pid(kid);
+ if(!th) continue;
+ funcall1(SymbolFunction(HANDLE_THREAD_EXIT),make_fixnum(kid));
+ destroy_thread(th);
+ }
+ }
+}
#endif
boolean handle_control_stack_guard_triggered(os_context_t *context,void *addr){
#endif
-/* this is also used by from gencgc.c alloc() */
+/* 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;
fake_foreign_function_call(context);
/* SUB-GC may return without GCing if *GC-INHIBIT* is set, in
* which case we will be running with no gc trigger barrier
* thing for a while. But it shouldn't be long until the end
* of WITHOUT-GCING. */
+
+ sigemptyset(&new);
+ sigaddset_blockable(&new);
+ /* enable signals before calling into Lisp */
+ sigprocmask(SIG_UNBLOCK,&new,0);
funcall0(SymbolFunction(SUB_GC));
undo_fake_foreign_function_call(context);
return 1;
sigemptyset(&new);
sigaddset_blockable(&new);
- FSHOW((stderr, "/interrupt_low_level_handlers[signal]=%d\n",
- interrupt_low_level_handlers[signal]));
+ FSHOW((stderr, "/data->interrupt_low_level_handlers[signal]=%d\n",
+ 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)) {