X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fbsd-os.c;h=6d1679007b29091401a6d9ac0d7cb6958af10c17;hb=3b90774a1ea68bf42579594c872de16fb33f1454;hp=0bd5fc9259b4a179ec5e201742bf93df3f2f7b5b;hpb=a499f2c9099d1dc2cb4227a2505eb4cc6f310e24;p=sbcl.git diff --git a/src/runtime/bsd-os.c b/src/runtime/bsd-os.c index 0bd5fc9..6d16790 100644 --- a/src/runtime/bsd-os.c +++ b/src/runtime/bsd-os.c @@ -23,6 +23,7 @@ #include #include #include +#include #include "sbcl.h" #include "./signal.h" #include "os.h" @@ -40,6 +41,9 @@ #include /* #include */ #include "validate.h" +#if defined LISP_FEATURE_GENCGC +#include "gencgc-internal.h" +#endif os_vm_size_t os_vm_page_size; @@ -47,6 +51,7 @@ os_vm_size_t os_vm_page_size; #include #include #include +#include /* For the stat-family wrappers. */ static void netbsd_init(); #endif /* __NetBSD__ */ @@ -64,24 +69,8 @@ os_init(char *argv[], char *envp[]) #ifdef __NetBSD__ netbsd_init(); -#endif /* __NetBSD__ */ -#ifdef __FreeBSD__ +#elif defined(__FreeBSD__) freebsd_init(); -#endif /* __FreeBSD__ */ -} - -int *os_context_pc_addr(os_context_t *context) -{ -#if defined __FreeBSD__ - return CONTEXT_ADDR_FROM_STEM(eip); -#elif defined __OpenBSD__ - return CONTEXT_ADDR_FROM_STEM(pc); -#elif defined __NetBSD__ - return CONTEXT_ADDR_FROM_STEM(EIP); -#elif defined LISP_FEATURE_DARWIN - return &context->uc_mcontext->ss.srr0; -#else -#error unsupported BSD variant #endif } @@ -91,9 +80,9 @@ os_context_sigmask_addr(os_context_t *context) /* (Unlike most of the other context fields that we access, the * signal mask field is a field of the basic, outermost context * struct itself both in FreeBSD 4.0 and in OpenBSD 2.6.) */ -#if defined __FreeBSD__ || __NetBSD__ || defined LISP_FEATURE_DARWIN +#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(LISP_FEATURE_DARWIN) return &context->uc_sigmask; -#elif defined __OpenBSD__ +#elif defined (__OpenBSD__) return &context->sc_mask; #else #error unsupported BSD variant @@ -164,12 +153,14 @@ is_valid_lisp_addr(os_vm_address_t addr) struct thread *th; if(in_range_p(addr, READ_ONLY_SPACE_START, READ_ONLY_SPACE_SIZE) || in_range_p(addr, STATIC_SPACE_START , STATIC_SPACE_SIZE) || - in_range_p(addr, DYNAMIC_SPACE_START , DYNAMIC_SPACE_SIZE)) + in_range_p(addr, DYNAMIC_SPACE_START , dynamic_space_size)) return 1; for_each_thread(th) { - if((th->control_stack_start <= addr) && (addr < th->control_stack_end)) + if(((os_vm_address_t)th->control_stack_start <= addr) && + (addr < (os_vm_address_t)th->control_stack_end)) return 1; - if(in_range_p(addr, th->binding_stack_start, BINDING_STACK_SIZE)) + if(in_range_p(addr, (lispobj)th->binding_stack_start, + BINDING_STACK_SIZE)) return 1; } return 0; @@ -185,42 +176,90 @@ is_valid_lisp_addr(os_vm_address_t addr) * The GENCGC needs to be hooked into whatever signal is raised for * page fault on this OS. */ -static void -memory_fault_handler(int signal, siginfo_t *siginfo, void *void_context) + +void +memory_fault_handler(int signal, siginfo_t *siginfo, void *void_context +#if defined(LISP_FEATURE_FREEBSD) && defined(LISP_FEATURE_X86_64) +/* FreeBSD/amd64 stores fault address only in undocumented 4th arg. */ + ,void *fault_addr +#endif + ) { - /* The way that we extract low level information like the fault - * address is not specified by POSIX. */ -#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) - void *fault_addr = siginfo->si_addr; -#elif defined LISP_FEATURE_DARWIN - void *fault_addr = siginfo->si_addr; + os_context_t *context = arch_os_get_context(&void_context); +#if defined(LISP_FEATURE_FREEBSD) && defined(LISP_FEATURE_X86_64) + /* KLUDGE: Store fault address into si_addr for compatibilities. */ + siginfo->si_addr = fault_addr; #else -#error unsupported BSD variant + void *fault_addr = arch_get_bad_addr(signal, siginfo, context); #endif - os_context_t *context = arch_os_get_context(&void_context); +#if defined(LISP_FEATURE_RESTORE_TLS_SEGMENT_REGISTER_FROM_CONTEXT) + FSHOW_SIGNAL((stderr, "/ TLS: restoring fs: %p in memory_fault_handler\n", + *CONTEXT_ADDR_FROM_STEM(fs))); + os_restore_tls_segment_register(context); +#endif + + FSHOW((stderr, "Memory fault at: %p, PC: %p\n", fault_addr, *os_context_pc_addr(context))); + if (!gencgc_handle_wp_violation(fault_addr)) - if(!handle_guard_page_triggered(context,fault_addr)) + if(!handle_guard_page_triggered(context,fault_addr)) { #ifdef LISP_FEATURE_C_STACK_IS_CONTROL_STACK - arrange_return_to_lisp_function(context, SymbolFunction(MEMORY_FAULT_ERROR)); + lisp_memory_fault_error(context, fault_addr); #else - interrupt_handle_now(signal, siginfo, context); + if (!interrupt_maybe_gc_int(signal, siginfo, context)) { + interrupt_handle_now(signal, siginfo, context); + } +#if defined(LISP_FEATURE_DARWIN) + /* Work around G5 bug; fix courtesy gbyers */ + DARWIN_FIX_CONTEXT(context); +#endif #endif + } +} + +#if defined(LISP_FEATURE_MACH_EXCEPTION_HANDLER) +void +mach_error_memory_fault_handler(int signal, siginfo_t *siginfo, void *void_context) { + lose("Unhandled memory fault. Exiting."); } +#endif + void os_install_interrupt_handlers(void) { SHOW("os_install_interrupt_handlers()/bsd-os/defined(GENCGC)"); +#if defined(LISP_FEATURE_MACH_EXCEPTION_HANDLER) undoably_install_low_level_interrupt_handler(SIG_MEMORY_FAULT, + mach_error_memory_fault_handler); +#else + undoably_install_low_level_interrupt_handler(SIG_MEMORY_FAULT, +#ifdef LISP_FEATURE_FREEBSD + (__siginfohandler_t *) +#endif memory_fault_handler); #ifdef SIG_MEMORY_FAULT2 undoably_install_low_level_interrupt_handler(SIG_MEMORY_FAULT2, +#ifdef LISP_FEATURE_FREEBSD + (__siginfohandler_t *) +#endif memory_fault_handler); #endif +#endif + +#ifdef LISP_FEATURE_SB_THREAD + undoably_install_low_level_interrupt_handler(SIG_INTERRUPT_THREAD, + interrupt_thread_handler); + undoably_install_low_level_interrupt_handler(SIG_STOP_FOR_GC, + sig_stop_for_gc_handler); +#ifdef SIG_RESUME_FROM_GC + undoably_install_low_level_interrupt_handler(SIG_RESUME_FROM_GC, + sig_stop_for_gc_handler); +#endif +#endif SHOW("leaving os_install_interrupt_handlers()"); } -#else /* Currently Darwin only */ +#else /* Currently PPC/Darwin/Cheney only */ static void sigsegv_handler(int signal, siginfo_t *info, void* void_context) @@ -287,6 +326,25 @@ The system may fail to start.\n", strerror(errno)); } } + +/* The stat() routines in NetBSD's C library are compatibility + wrappers for some very old version of the stat buffer structure. + Programs must be processed by the C toolchain in order to get an + up-to-date definition of the stat() routine. These wrappers are + used only in sb-posix, as of 2006-10-15. -- RMK */ +int _stat(const char *path, struct stat *sb) { + return (stat(path, sb)); +} + +int _lstat(const char *path, struct stat *sb) { + return (lstat(path, sb)); +} + +int _fstat(int fd, struct stat *sb) { + return (fstat(fd, sb)); +} + + #endif /* __NetBSD__ */ #ifdef __FreeBSD__ @@ -311,27 +369,60 @@ static void freebsd_init() #endif /* LISP_FEATURE_X86 */ } #endif /* __FreeBSD__ */ - -/* threads */ -/* no threading in any *BSD variant on any CPU (yet? in sbcl-0.8.0 anyway) */ -#ifdef LISP_FEATURE_SB_THREAD -#error "Define threading support functions" -#else -int arch_os_thread_init(struct thread *thread) { - stack_t sigstack; -#ifdef LISP_FEATURE_C_STACK_IS_CONTROL_STACK - /* Signal handlers are run on the control stack, so if it is exhausted - * we had better use an alternate stack for whatever signal tells us - * we've exhausted it */ - sigstack.ss_sp=((void *) thread)+dynamic_values_bytes; - sigstack.ss_flags=0; - sigstack.ss_size = 32*SIGSTKSZ; - sigaltstack(&sigstack,0); +#ifdef LISP_FEATURE_DARWIN +/* defined in ppc-darwin-os.c instead */ +#elif defined(LISP_FEATURE_FREEBSD) +#ifndef KERN_PROC_PATHNAME +#define KERN_PROC_PATHNAME 12 #endif - return 1; /* success */ + +extern int getosreldate(void); + +char * +os_get_runtime_executable_path() +{ + char path[PATH_MAX + 1]; + + if (getosreldate() >= 600024) { + /* KERN_PROC_PATHNAME is available */ + size_t len = PATH_MAX + 1; + int mib[4]; + + mib[0] = CTL_KERN; + mib[1] = KERN_PROC; + mib[2] = KERN_PROC_PATHNAME; + mib[3] = -1; + if (sysctl(mib, 4, &path, &len, NULL, 0) != 0) + return NULL; + } else { + int size; + size = readlink("/proc/curproc/file", path, sizeof(path) - 1); + if (size < 0) + return NULL; + path[size] = '\0'; + } + if (strcmp(path, "unknown") == 0) + return NULL; + return copied_string(path); } -int arch_os_thread_cleanup(struct thread *thread) { - return 1; /* success */ +#elif defined(LISP_FEATURE_NETBSD) +char * +os_get_runtime_executable_path() +{ + struct stat sb; + char *path = strdup("/proc/curproc/file"); + if (path && ((stat(path, &sb)) == 0)) + return path; + else { + fprintf(stderr, "Couldn't stat /proc/curproc/file; is /proc mounted?\n"); + return NULL; + } +} +#else /* Not DARWIN or FREEBSD or NETBSD */ +char * +os_get_runtime_executable_path() +{ + return NULL; } #endif