X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fbsd-os.c;h=f9cf70c8b92ca088847f2d21a3647e4980d40c48;hb=5de74c72e5a9522c7fdd3dbb31a39641e9de8877;hp=722776329142518d8ef6b06297934ae1705c0816;hpb=c9bb20c4b0d1f232ec83569d3456b3f3edc4aa1c;p=sbcl.git diff --git a/src/runtime/bsd-os.c b/src/runtime/bsd-os.c index 7227763..f9cf70c 100644 --- a/src/runtime/bsd-os.c +++ b/src/runtime/bsd-os.c @@ -21,6 +21,9 @@ #include #include #include +#include +#include +#include "sbcl.h" #include "./signal.h" #include "os.h" #include "arch.h" @@ -28,95 +31,72 @@ #include "interrupt.h" #include "interr.h" #include "lispregs.h" -#include "sbcl.h" +#include "thread.h" +#include "runtime.h" +#include "genesis/static-symbols.h" +#include "genesis/fdefn.h" #include #include /* #include */ -#include #include "validate.h" -vm_size_t os_vm_page_size; + +os_vm_size_t os_vm_page_size; -#if defined GENCGC -#include "gencgc.h" -#endif +#ifdef __NetBSD__ +#include +#include +#include + +static void netbsd_init(); +#endif /* __NetBSD__ */ + +#ifdef __FreeBSD__ +#include +#include + +static void freebsd_init(); +#endif /* __FreeBSD__ */ -/* The different BSD variants have diverged in exactly where they - * store signal context information, but at least they tend to use the - * same stems to name the structure fields, so by using this macro we - * can share a fair amount of code between different variants. */ -#if defined __FreeBSD__ -#define CONTEXT_ADDR_FROM_STEM(stem) &context->uc_mcontext.mc_ ## stem -#elif defined __OpenBSD__ -#define CONTEXT_ADDR_FROM_STEM(stem) &context->sc_ ## stem -#else -#error unsupported BSD variant -#endif - void -os_init(void) +os_init(char *argv[], char *envp[]) { os_vm_page_size = getpagesize(); -} -/* KLUDGE: There is strong family resemblance in the signal context - * stuff in FreeBSD and OpenBSD, but in detail they're different in - * almost every line of code. It would be nice to find some way to - * factor out the commonality better; failing that, it might be best - * just to split this generic-BSD code into one variant for each BSD. */ - -int * -os_context_register_addr(os_context_t *context, int offset) -{ - switch(offset) { - case 0: - return CONTEXT_ADDR_FROM_STEM(eax); - case 2: - return CONTEXT_ADDR_FROM_STEM(ecx); - case 4: - return CONTEXT_ADDR_FROM_STEM(edx); - case 6: - return CONTEXT_ADDR_FROM_STEM(ebx); - case 8: - return CONTEXT_ADDR_FROM_STEM(esp); - case 10: - return CONTEXT_ADDR_FROM_STEM(ebp); - case 12: - return CONTEXT_ADDR_FROM_STEM(esi); - case 14: - return CONTEXT_ADDR_FROM_STEM(edi); - default: - return 0; - } +#ifdef __NetBSD__ + netbsd_init(); +#endif /* __NetBSD__ */ +#ifdef __FreeBSD__ + freebsd_init(); +#endif /* __FreeBSD__ */ } -int * -os_context_pc_addr(os_context_t *context) +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) && defined(LISP_FEATURE_X86) + return CONTEXT_ADDR_FROM_STEM(eip); +#elif defined LISP_FEATURE_DARWIN + return &context->uc_mcontext->ss.srr0; #else #error unsupported BSD variant #endif } -int * -os_context_sp_addr(os_context_t *context) -{ - return CONTEXT_ADDR_FROM_STEM(esp); -} - sigset_t * 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__ +#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 @@ -129,13 +109,13 @@ os_validate(os_vm_address_t addr, os_vm_size_t len) int flags = MAP_PRIVATE | MAP_ANON; if (addr) - flags |= MAP_FIXED; + flags |= MAP_FIXED; addr = mmap(addr, len, OS_VM_PROT_ALL, flags, -1, 0); if (addr == MAP_FAILED) { - perror("mmap"); - return NULL; + perror("mmap"); + return NULL; } return addr; @@ -145,35 +125,30 @@ void os_invalidate(os_vm_address_t addr, os_vm_size_t len) { if (munmap(addr, len) == -1) - perror("munmap"); + perror("munmap"); } os_vm_address_t os_map(int fd, int offset, os_vm_address_t addr, os_vm_size_t len) { addr = mmap(addr, len, - OS_VM_PROT_ALL, - MAP_PRIVATE | MAP_FILE | MAP_FIXED, - fd, (off_t) offset); + OS_VM_PROT_ALL, + MAP_PRIVATE | MAP_FILE | MAP_FIXED, + fd, (off_t) offset); if (addr == MAP_FAILED) { - perror("mmap"); - lose("unexpected mmap(..) failure"); + perror("mmap"); + lose("unexpected mmap(..) failure\n"); } return addr; } void -os_flush_icache(os_vm_address_t address, os_vm_size_t length) -{ -} - -void os_protect(os_vm_address_t address, os_vm_size_t length, os_vm_prot_t prot) { if (mprotect(address, length, prot) == -1) { - perror("mprotect"); + perror("mprotect"); } } @@ -189,24 +164,25 @@ in_range_p(os_vm_address_t a, lispobj sbeg, size_t slen) boolean is_valid_lisp_addr(os_vm_address_t addr) { - return 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, CONTROL_STACK_START , CONTROL_STACK_SIZE ) - || in_range_p(addr, BINDING_STACK_START , BINDING_STACK_SIZE ); + 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)) + return 1; + for_each_thread(th) { + if((th->control_stack_start <= addr) && (addr < th->control_stack_end)) + return 1; + if(in_range_p(addr, th->binding_stack_start, BINDING_STACK_SIZE)) + return 1; + } + return 0; } /* * any OS-dependent special low-level handling for signals */ -#if !defined GENCGC - -void -os_install_interrupt_handlers(void) -{} - -#else +#if defined LISP_FEATURE_GENCGC /* * The GENCGC needs to be hooked into whatever signal is raised for @@ -215,29 +191,199 @@ os_install_interrupt_handlers(void) static void memory_fault_handler(int signal, siginfo_t *siginfo, void *void_context) { - /* The way that we extract low level information like the fault - * address is not specified by POSIX. */ -#if defined __FreeBSD__ - void *fault_addr = siginfo->si_addr; -#elif defined __OpenBSD__ - void *fault_addr = siginfo->si_addr; + os_context_t *context = arch_os_get_context(&void_context); + void *fault_addr = arch_get_bad_addr(signal, siginfo, context); + +#if defined(MEMORY_FAULT_DEBUG) + fprintf(stderr, "Memory fault at: %p, PC: %x\n", fault_addr, *os_context_pc_addr(context)); +#if defined(ARCH_HAS_STACK_POINTER) + fprintf(stderr, "Stack pointer: %x\n", *os_context_sp_addr(context)); +#endif +#endif + + if (!gencgc_handle_wp_violation(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)); #else -#error unsupported BSD variant + 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 - if (!gencgc_handle_wp_violation(fault_addr)) { - interrupt_handle_now(signal, siginfo, void_context); - } +#endif + } } + void os_install_interrupt_handlers(void) { -#if defined __FreeBSD__ - interrupt_install_low_level_handler(SIGBUS, memory_fault_handler); -#elif defined __OpenBSD__ - interrupt_install_low_level_handler(SIGSEGV, memory_fault_handler); + SHOW("os_install_interrupt_handlers()/bsd-os/defined(GENCGC)"); + undoably_install_low_level_interrupt_handler(SIG_MEMORY_FAULT, + memory_fault_handler); +#ifdef SIG_MEMORY_FAULT2 + undoably_install_low_level_interrupt_handler(SIG_MEMORY_FAULT2, + memory_fault_handler); +#endif + SHOW("leaving os_install_interrupt_handlers()"); +} + +#else /* Currently Darwin only */ + +static void +sigsegv_handler(int signal, siginfo_t *info, void* void_context) +{ + os_context_t *context = arch_os_get_context(&void_context); + unsigned int pc = (unsigned int *)(*os_context_pc_addr(context)); + os_vm_address_t addr; + + addr = arch_get_bad_addr(signal,info,context); + if(!interrupt_maybe_gc(signal, info, context)) + if(!handle_guard_page_triggered(context,addr)) + interrupt_handle_now(signal, info, context); + /* Work around G5 bug; fix courtesy gbyers */ + DARWIN_FIX_CONTEXT(context); +} + +void +os_install_interrupt_handlers(void) +{ + SHOW("os_install_interrupt_handlers()/bsd-os/!defined(GENCGC)"); + undoably_install_low_level_interrupt_handler(SIG_MEMORY_FAULT, + sigsegv_handler); +#ifdef SIG_MEMORY_FAULT2 + undoably_install_low_level_interrupt_handler(SIG_MEMORY_FAULT2, + sigsegv_handler); +#endif +} + +#endif /* defined GENCGC */ + +#ifdef __NetBSD__ +static void netbsd_init() +{ + struct rlimit rl; + int mib[2], osrev; + size_t len; + + /* Are we running on a sufficiently functional kernel? */ + mib[0] = CTL_KERN; + mib[1] = KERN_OSREV; + + len = sizeof(osrev); + sysctl(mib, 2, &osrev, &len, NULL, 0); + + /* If we're older than 2.0... */ + if (osrev < 200000000) { + fprintf(stderr, "osrev = %d (needed at least 200000000).\n", osrev); + lose("NetBSD kernel too old to run sbcl.\n"); + } + + /* NetBSD counts mmap()ed space against the process's data size limit, + * so yank it up. This might be a nasty thing to do? */ + getrlimit (RLIMIT_DATA, &rl); + /* Amazingly for such a new port, the provenance and meaning of + this number are unknown. It might just mean REALLY_BIG_LIMIT, + or possibly it should be calculated from dynamic space size. + -- CSR, 2004-04-08 */ + rl.rlim_cur = 1073741824; + if (setrlimit (RLIMIT_DATA, &rl) < 0) { + fprintf (stderr, + "RUNTIME WARNING: unable to raise process data size limit:\n\ + %s.\n\ +The system may fail to start.\n", + strerror(errno)); + } +} +#endif /* __NetBSD__ */ + +#ifdef __FreeBSD__ +static void freebsd_init() +{ + /* Quote from sbcl-devel (NIIMI Satoshi): "Some OSes, like FreeBSD + * 4.x with GENERIC kernel, does not enable SSE support even on + * SSE capable CPUs". Detect this situation and skip the + * fast_bzero sse/base selection logic that's normally done in + * x86-assem.S. + */ +#ifdef LISP_FEATURE_X86 + size_t len; + int instruction_sse; + + len = sizeof(instruction_sse); + if (sysctlbyname("hw.instruction_sse", &instruction_sse, &len, NULL, 0) == 0 + && instruction_sse != 0) { + /* Use the SSE detector */ + fast_bzero_pointer = fast_bzero_detect; + } +#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 -#error unsupported BSD variant +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); #endif + return 1; /* success */ } +int arch_os_thread_cleanup(struct thread *thread) { + return 1; /* success */ +} +#endif -#endif /* !defined GENCGC */ +#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 + +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); +} +#else /* Not DARWIN or FREEBSD */ +char * +os_get_runtime_executable_path() +{ + return NULL; +} +#endif