#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"
boolean interrupt_maybe_gc_int(int signal, siginfo_t *info, void *v_context);
extern volatile lispobj all_threads_lock;
-extern volatile int countdown_to_gc;
/*
* This is a workaround for some slightly silly Linux/GNU Libc
#ifdef LISP_FEATURE_SB_THREAD
sigaddset(s, SIG_STOP_FOR_GC);
sigaddset(s, SIG_INTERRUPT_THREAD);
- sigaddset(s, SIG_THREAD_EXIT);
#endif
}
if (internal_errors_enabled) {
SHOW("in interrupt_internal_error");
-#if QSHOW
+#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. */
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 ss;
+ int i;
if(maybe_defer_handler(sig_stop_for_gc_handler,data,
- signal,info,context)){
+ signal,info,context)) {
return;
}
/* need the context stored so it can have registers scavenged */
fake_foreign_function_call(context);
- get_spinlock(&all_threads_lock,thread->pid);
- countdown_to_gc--;
+ sigemptyset(&ss);
+ for(i=1;i<NSIG;i++) sigaddset(&ss,i); /* Block everything. */
+ sigprocmask(SIG_BLOCK,&ss,0);
+
thread->state=STATE_STOPPED;
- release_spinlock(&all_threads_lock);
- kill(thread->pid,SIGSTOP);
+
+ 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
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 ;
- }
+ int status;
+
while(1) {
kid=waitpid(-1,&status,__WALL|WNOHANG);
- if(kid<1) break;
+ if(kid<=0) 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);
+ if(th) th->state=STATE_DEAD;
}
}
}
+
+
#endif
boolean handle_control_stack_guard_triggered(os_context_t *context,void *addr){
}
#ifndef LISP_FEATURE_GENCGC
-/* This function gets called from the SIGSEGV (for e.g. Linux or
+/* This function gets called from the SIGSEGV (for e.g. Linux, NetBSD, &
* 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. */
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)) {