src/runtime/bsd-os.c

   1 /*
   2  * OS-dependent routines for BSD-ish systems
   3  *
   4  * This file (along with os.h) exports an OS-independent interface to
   5  * the operating system VM facilities. This interface looks a lot like
   6  * the Mach interface (but simpler in some places). For some operating
   7  * systems, a subset of these functions will have to be emulated.
   8  */
   9
  10 /*
  11  * This software is part of the SBCL system. See the README file for
  12  * more information.
  13  *
  14  * This software is derived from the CMU CL system, which was
  15  * written at Carnegie Mellon University and released into the
  16  * public domain. The software is in the public domain and is
  17  * provided with absolutely no warranty. See the COPYING and CREDITS
  18  * files for more information.
  19  */
  20
  21 #include <stdio.h>
  22 #include <sys/param.h>
  23 #include <sys/file.h>
  24 #include "./signal.h"
  25 #include "os.h"
  26 #include "arch.h"
  27 #include "globals.h"
  28 #include "interrupt.h"
  29 #include "interr.h"
  30 #include "lispregs.h"
  31 #include "sbcl.h"
  32
  33 #include <sys/types.h>
  34 #include <signal.h>
  35 /* #include <sys/sysinfo.h> */
  36 #include <sys/proc.h>
  37 #include "validate.h"
  38 vm_size_t os_vm_page_size;
  39
  40
  41 /* The different BSD variants have diverged in exactly where they
  42  * store signal context information, but at least they tend to use the
  43  * same stems to name the structure fields, so by using this macro we
  44  * can share a fair amount of code between different variants. */
  45 #if defined __FreeBSD__
  46 #define CONTEXT_ADDR_FROM_STEM(stem) &context->uc_mcontext.mc_ ## stem
  47 #elif defined __OpenBSD__
  48 #define CONTEXT_ADDR_FROM_STEM(stem) &context->sc_ ## stem
  49 #else
  50 #error unsupported BSD variant
  51 #endif
  52 \f
  53 void
  54 os_init(void)
  55 {
  56     os_vm_page_size = getpagesize();
  57 }
  58
  59 /* KLUDGE: There is strong family resemblance in the signal context
  60  * stuff in FreeBSD and OpenBSD, but in detail they're different in
  61  * almost every line of code. It would be nice to find some way to
  62  * factor out the commonality better; failing that, it might be best
  63  * just to split this generic-BSD code into one variant for each BSD. */
  64
  65 int *
  66 os_context_register_addr(os_context_t *context, int offset)
  67 {
  68     switch(offset) {
  69     case  0:
  70         return CONTEXT_ADDR_FROM_STEM(eax);
  71     case  2:
  72         return CONTEXT_ADDR_FROM_STEM(ecx);
  73     case  4:
  74         return CONTEXT_ADDR_FROM_STEM(edx);
  75     case  6:
  76         return CONTEXT_ADDR_FROM_STEM(ebx);
  77     case  8:
  78         return CONTEXT_ADDR_FROM_STEM(esp);
  79     case 10:
  80         return CONTEXT_ADDR_FROM_STEM(ebp);
  81     case 12:
  82         return CONTEXT_ADDR_FROM_STEM(esi);
  83     case 14:
  84         return CONTEXT_ADDR_FROM_STEM(edi);
  85     default:
  86         return 0;
  87     }
  88 }
  89
  90 int *
  91 os_context_pc_addr(os_context_t *context)
  92 {
  93 #if defined __FreeBSD__
  94     return CONTEXT_ADDR_FROM_STEM(eip);
  95 #elif defined __OpenBSD__
  96     return CONTEXT_ADDR_FROM_STEM(pc);
  97 #else
  98 #error unsupported BSD variant
  99 #endif
 100 }
 101
 102 int *
 103 os_context_sp_addr(os_context_t *context)
 104 {
 105     return CONTEXT_ADDR_FROM_STEM(esp);
 106 }
 107
 108 sigset_t *
 109 os_context_sigmask_addr(os_context_t *context)
 110 {
 111     /* (Unlike most of the other context fields that we access, the
 112      * signal mask field is a field of the basic, outermost context
 113      * struct itself both in FreeBSD 4.0 and in OpenBSD 2.6.) */
 114 #if defined __FreeBSD__
 115     return &context->uc_sigmask;
 116 #elif defined __OpenBSD__
 117     return &context->sc_mask;
 118 #else
 119 #error unsupported BSD variant
 120 #endif
 121 }
 122
 123 os_vm_address_t
 124 os_validate(os_vm_address_t addr, os_vm_size_t len)
 125 {
 126     int flags = MAP_PRIVATE | MAP_ANON;
 127
 128     if (addr)
 129         flags |= MAP_FIXED;
 130
 131     addr = mmap(addr, len, OS_VM_PROT_ALL, flags, -1, 0);
 132
 133     if (addr == MAP_FAILED) {
 134         perror("mmap");
 135         return NULL;
 136     }
 137
 138     return addr;
 139 }
 140
 141 void
 142 os_invalidate(os_vm_address_t addr, os_vm_size_t len)
 143 {
 144     if (munmap(addr, len) == -1)
 145         perror("munmap");
 146 }
 147
 148 os_vm_address_t
 149 os_map(int fd, int offset, os_vm_address_t addr, os_vm_size_t len)
 150 {
 151     addr = mmap(addr, len,
 152                 OS_VM_PROT_ALL,
 153                 MAP_PRIVATE | MAP_FILE | MAP_FIXED,
 154                 fd, (off_t) offset);
 155
 156     if (addr == MAP_FAILED) {
 157         perror("mmap");
 158         lose("unexpected mmap(..) failure");
 159     }
 160
 161     return addr;
 162 }
 163
 164 /* FIXME: If this can be a no-op on BSD/x86, then it
 165  * deserves a more precise name.
 166  *
 167  * (Perhaps os_prepare_data_area_to_be_executed()?) */
 168 void
 169 os_flush_icache(os_vm_address_t address, os_vm_size_t length)
 170 {
 171 }
 172
 173 void
 174 os_protect(os_vm_address_t address, os_vm_size_t length, os_vm_prot_t prot)
 175 {
 176     if (mprotect(address, length, prot) == -1) {
 177         perror("mprotect");
 178     }
 179 }
 180 \f
 181 static boolean
 182 in_range_p(os_vm_address_t a, lispobj sbeg, size_t slen)
 183 {
 184     char* beg = (char*) sbeg;
 185     char* end = (char*) sbeg + slen;
 186     char* adr = (char*) a;
 187     return (adr >= beg && adr < end);
 188 }
 189
 190 boolean
 191 is_valid_lisp_addr(os_vm_address_t addr)
 192 {
 193     return in_range_p(addr, READ_ONLY_SPACE_START, READ_ONLY_SPACE_SIZE)
 194         || in_range_p(addr, STATIC_SPACE_START   , STATIC_SPACE_SIZE   )
 195         || in_range_p(addr, DYNAMIC_SPACE_START  , DYNAMIC_SPACE_SIZE  )
 196         || in_range_p(addr, CONTROL_STACK_START  , CONTROL_STACK_SIZE  )
 197         || in_range_p(addr, BINDING_STACK_START  , BINDING_STACK_SIZE  );
 198 }
 199 \f
 200 /*
 201  * any OS-dependent special low-level handling for signals
 202  */
 203
 204 #if defined LISP_FEATURE_GENCGC
 205
 206 /*
 207  * The GENCGC needs to be hooked into whatever signal is raised for
 208  * page fault on this OS.
 209  */
 210 static void
 211 memory_fault_handler(int signal, siginfo_t *siginfo, void *void_context)
 212 {
 213     /* The way that we extract low level information like the fault
 214      * address is not specified by POSIX. */
 215 #if defined __FreeBSD__
 216     void *fault_addr = siginfo->si_addr;
 217 #elif defined __OpenBSD__
 218     void *fault_addr = siginfo->si_addr;
 219 #else
 220 #error unsupported BSD variant
 221 #endif
 222     os_context_t *context = arch_os_get_context(&void_context);
 223    if (!gencgc_handle_wp_violation(fault_addr))
 224         if(!handle_control_stack_guard_triggered(context,fault_addr))
 225             /* FIXME is this context or void_context?  not that it */
 226             /* makes a difference currently except on linux/sparc */
 227             interrupt_handle_now(signal, siginfo, void_context);
 228 }
 229 void
 230 os_install_interrupt_handlers(void)
 231 {
 232     SHOW("os_install_interrupt_handlers()/bsd-os/defined(GENCGC)");
 233     undoably_install_low_level_interrupt_handler(SIG_MEMORY_FAULT,
 234                                                  memory_fault_handler);
 235     SHOW("leaving os_install_interrupt_handlers()");
 236 }
 237
 238 #else
 239 /* As of 2002.07.31, this configuration has never been tested */
 240 void
 241 os_install_interrupt_handlers(void)
 242 {
 243     SHOW("os_install_interrupt_handlers()/bsd-os/!defined(GENCGC)");
 244 }
 245
 246 #endif /* defined GENCGC */