src/runtime/osf1-os.c

   1 /*
   2  * This file (along with os.h) exports an OS-independent interface to
   3  * the operating system VM facilities. Surprise surprise, this
   4  * interface looks a lot like the Mach interface (but simpler in some
   5  * places). For some operating systems, a subset of these functions
   6  * will have to be emulated.
   7  *
   8  * This is the OSF/1 version, based on the Linux version, itself based
   9  * on the OSF1 version from CMUCL by Sean Hallgren.  Now _there's_
  10  * a metacircularity for you ...
  11  */
  12
  13 /*
  14  * This software is part of the SBCL system. See the README file for
  15  * more information.
  16  *
  17  * This software is derived from the CMU CL system, which was
  18  * written at Carnegie Mellon University and released into the
  19  * public domain. The software is in the public domain and is
  20  * provided with absolutely no warranty. See the COPYING and CREDITS
  21  * files for more information.
  22  */
  23
  24 #include <stdio.h>
  25 #include <sys/param.h>
  26 #include <sys/file.h>
  27 #include "sbcl.h"
  28 #include "./signal.h"
  29 #include "os.h"
  30 #include "arch.h"
  31 #include "globals.h"
  32 #include "interrupt.h"
  33 #include "interr.h"
  34 #include "lispregs.h"
  35 #include <sys/socket.h>
  36 #include <sys/utsname.h>
  37 #include <errno.h>
  38 #include <sys/sysinfo.h>
  39 #include <sys/proc.h>
  40 #include <sys/mman.h>
  41 #include <machine/hal_sysinfo.h>
  42
  43 #include <sys/types.h>
  44 #include <signal.h>
  45 #include <sys/time.h>
  46 #include <sys/stat.h>
  47 #include <unistd.h>
  48
  49 #include "validate.h"
  50 size_t os_vm_page_size;
  51
  52 \f
  53
  54 void os_init(void)
  55 {
  56     os_vm_page_size = getpagesize();
  57 }
  58
  59
  60 os_vm_address_t
  61 os_validate(os_vm_address_t addr, os_vm_size_t len)
  62 {
  63     int flags = MAP_PRIVATE|MAP_ANONYMOUS;
  64     if (addr) flags |= MAP_FIXED;
  65     else  flags |= MAP_VARIABLE;
  66
  67     if((addr=mmap(addr,len,OS_VM_PROT_ALL,flags,-1,0)) == (os_vm_address_t) -1)
  68         perror("mmap");
  69
  70     return addr;
  71 }
  72
  73 void
  74 os_invalidate(os_vm_address_t addr, os_vm_size_t len)
  75 {
  76     if (munmap(addr,len) == -1) {
  77         perror("munmap");
  78     }
  79 }
  80
  81 os_vm_address_t
  82 os_map(int fd, int offset, os_vm_address_t addr, os_vm_size_t len)
  83 {
  84     addr = mmap(addr, len,
  85                 OS_VM_PROT_ALL,
  86                 MAP_PRIVATE | MAP_FILE | MAP_FIXED,
  87                 fd, (off_t) offset);
  88
  89     if (addr == MAP_FAILED) {
  90         perror("mmap");
  91         lose("unexpected mmap(..) failure");
  92     }
  93
  94     return addr;
  95 }
  96
  97 void
  98 os_protect(os_vm_address_t address, os_vm_size_t length, os_vm_prot_t prot)
  99 {
 100     if (mprotect(address, length, prot) == -1) {
 101         perror("mprotect");
 102     }
 103 }
 104
 105 boolean
 106 is_valid_lisp_addr(os_vm_address_t addr)
 107 {
 108     int ret;
 109     os_vm_address_t newaddr;
 110     newaddr=os_trunc_to_page(addr);
 111     if((ret=mvalid(newaddr,newaddr-addr+4,OS_VM_PROT_ALL)) == 0)
 112         return TRUE;
 113     else if(errno==EINVAL)
 114         perror("mvalid");
 115     return FALSE;
 116 }
 117 \f
 118 /*
 119  * any OS-dependent special low-level handling for signals
 120  */
 121
 122
 123 static void
 124 sigsegv_handler(int signal, siginfo_t *info, void* void_context)
 125 {
 126     os_context_t *context = arch_os_get_context(&void_context);
 127
 128     os_vm_address_t addr = arch_get_bad_addr(signal,info,context);
 129
 130     if (addr != NULL &&
 131         *os_context_register_addr(context,reg_ALLOC) & (1L<<63)){
 132         /* this is lifted from linux-os.c, so violates OOAO */
 133         *os_context_register_addr(context,reg_ALLOC) -= (1L<<63);
 134         interrupt_handle_pending(context);
 135     } else if (!interrupt_maybe_gc(signal, info, context)) {
 136         if(!handle_guard_page_triggered(context,addr))
 137             interrupt_handle_now(signal, info, context);
 138     }
 139 }
 140
 141
 142 void
 143 os_install_interrupt_handlers(void)
 144 {
 145     undoably_install_low_level_interrupt_handler(SIG_MEMORY_FAULT,
 146                                                  sigsegv_handler);
 147 }
 148