0.9.2.49:
[sbcl.git] / src / runtime / linux-os.c
1 /*
2  * the Linux incarnation of OS-dependent routines.  See also
3  * $(sbcl_arch)-linux-os.c
4  *
5  * This file (along with os.h) exports an OS-independent interface to
6  * the operating system VM facilities. Surprise surprise, this
7  * interface looks a lot like the Mach interface (but simpler in some
8  * places). For some operating systems, a subset of these functions
9  * will have to be emulated.
10  */
11
12 /*
13  * This software is part of the SBCL system. See the README file for
14  * more information.
15  *
16  * This software is derived from the CMU CL system, which was
17  * written at Carnegie Mellon University and released into the
18  * public domain. The software is in the public domain and is
19  * provided with absolutely no warranty. See the COPYING and CREDITS
20  * files for more information.
21  */
22
23 #include <stdio.h>
24 #include <sys/param.h>
25 #include <sys/file.h>
26 #include "sbcl.h"
27 #include "./signal.h"
28 #include "os.h"
29 #include "arch.h"
30 #include "globals.h"
31 #include "interrupt.h"
32 #include "interr.h"
33 #include "lispregs.h"
34 #include "runtime.h"
35 #include "genesis/static-symbols.h"
36 #include "genesis/fdefn.h"
37 #include <sys/socket.h>
38 #include <sys/utsname.h>
39
40 #include <sys/types.h>
41 #include <signal.h>
42 /* #include <sys/sysinfo.h> */
43 #include <sys/time.h>
44 #include <sys/stat.h>
45 #include <unistd.h>
46 #include <linux/version.h>
47
48 #include "validate.h"
49 #include "thread.h"
50 size_t os_vm_page_size;
51
52 #ifdef LISP_FEATURE_SB_THREAD
53 #include <linux/unistd.h>
54 #include <errno.h>
55
56 /* values taken from the kernel's linux/futex.h.  This header file
57    doesn't exist in userspace, which is our excuse for not grovelling
58    them automatically */
59 #define FUTEX_WAIT (0)
60 #define FUTEX_WAKE (1)
61 #define FUTEX_FD (2)
62 #define FUTEX_REQUEUE (3)
63
64 #define __NR_sys_futex __NR_futex
65
66 _syscall4(int,sys_futex,
67           int *, futex,
68           int, op,
69           int, val,
70           struct timespec *, rel);
71 #endif
72
73 #include "gc.h"
74 \f
75 int linux_sparc_siginfo_bug = 0;
76 int linux_no_threads_p = 0;
77
78 void
79 os_init(void)
80 {
81     /* Conduct various version checks: do we have enough mmap(), is
82      * this a sparc running 2.2, can we do threads? */
83 #ifdef LISP_FEATURE_SB_THREAD
84     int *futex=0;
85 #endif
86     struct utsname name;
87     int major_version;
88     int minor_version;
89     char *p;
90     uname(&name);
91     p=name.release;
92     major_version = atoi(p);
93     p=strchr(p,'.')+1;
94     minor_version = atoi(p);
95     if (major_version<2) {
96         lose("linux kernel version too old: major version=%d (can't run in version < 2.0.0)",
97              major_version);
98     }
99     if (!(major_version>2 || minor_version >= 4)) {
100 #ifdef LISP_FEATURE_SPARC
101         FSHOW((stderr,"linux kernel %d.%d predates 2.4;\n enabling workarounds for SPARC kernel bugs in signal handling.\n", major_version,minor_version));
102         linux_sparc_siginfo_bug = 1;
103 #endif
104     }
105 #ifdef LISP_FEATURE_SB_THREAD
106     futex_wait(futex,-1);
107     if(errno==ENOSYS)  linux_no_threads_p = 1;
108     if(linux_no_threads_p)
109         fprintf(stderr,"Linux with NPTL support (e.g. kernel 2.6 or newer) required for \nthread-enabled SBCL.  Disabling thread support.\n\n");
110 #endif
111     os_vm_page_size = getpagesize();
112 }
113
114
115 #ifdef LISP_FEATURE_ALPHA
116 /* The Alpha is a 64 bit CPU.  SBCL is a 32 bit application.  Due to all
117  * the places that assume we can get a pointer into a fixnum with no
118  * information loss, we have to make sure it allocates all its ram in the
119  * 0-2Gb region.  */
120
121 static void * under_2gb_free_pointer=DYNAMIC_1_SPACE_END;
122 #endif
123
124 os_vm_address_t
125 os_validate(os_vm_address_t addr, os_vm_size_t len)
126 {
127     int flags =  MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE;
128     os_vm_address_t actual ;
129
130     if (addr)
131         flags |= MAP_FIXED;
132 #ifdef LISP_FEATURE_ALPHA
133     else {
134         flags |= MAP_FIXED;
135         addr=under_2gb_free_pointer;
136     }
137 #endif
138     actual = mmap(addr, len, OS_VM_PROT_ALL, flags, -1, 0);
139     if (actual == MAP_FAILED || (addr && (addr!=actual))) {
140         perror("mmap");
141         return 0;               /* caller should check this */
142     }
143
144 #ifdef LISP_FEATURE_ALPHA
145
146     len=(len+(os_vm_page_size-1))&(~(os_vm_page_size-1));
147     under_2gb_free_pointer+=len;
148 #endif
149
150     return actual;
151 }
152
153 void
154 os_invalidate(os_vm_address_t addr, os_vm_size_t len)
155 {
156     if (munmap(addr,len) == -1) {
157         perror("munmap");
158     }
159 }
160
161 os_vm_address_t
162 os_map(int fd, int offset, os_vm_address_t addr, os_vm_size_t len)
163 {
164     os_vm_address_t actual;
165
166     actual = mmap(addr, len, OS_VM_PROT_ALL, MAP_PRIVATE | MAP_FIXED,
167                   fd, (off_t) offset);
168     if (actual == MAP_FAILED || (addr && (addr != actual))) {
169         perror("mmap");
170         lose("unexpected mmap(..) failure");
171     }
172
173     return actual;
174 }
175
176 void
177 os_protect(os_vm_address_t address, os_vm_size_t length, os_vm_prot_t prot)
178 {
179     if (mprotect(address, length, prot) == -1) {
180         perror("mprotect");
181     }
182 }
183 \f
184 boolean
185 is_valid_lisp_addr(os_vm_address_t addr)
186 {
187     struct thread *th;
188     size_t ad = (size_t) addr;
189
190     if ((READ_ONLY_SPACE_START <= ad && ad < READ_ONLY_SPACE_END)
191         || (STATIC_SPACE_START <= ad && ad < STATIC_SPACE_END)
192 #if defined LISP_FEATURE_GENCGC
193         || (DYNAMIC_SPACE_START <= ad && ad < DYNAMIC_SPACE_END)
194 #else
195         || (DYNAMIC_0_SPACE_START <= ad && ad < DYNAMIC_0_SPACE_END)
196         || (DYNAMIC_1_SPACE_START <= ad && ad < DYNAMIC_1_SPACE_END)
197 #endif
198         )
199         return 1;
200     for_each_thread(th) {
201         if((size_t)(th->control_stack_start) <= ad
202            && ad < (size_t)(th->control_stack_end))
203             return 1;
204         if((size_t)(th->binding_stack_start) <= ad
205            && ad < (size_t)(th->binding_stack_start + BINDING_STACK_SIZE))
206             return 1;
207     }
208     return 0;
209 }
210 \f
211 /*
212  * any OS-dependent special low-level handling for signals
213  */
214
215
216 #if defined LISP_FEATURE_GENCGC
217
218 /*
219  * The GENCGC needs to be hooked into whatever signal is raised for
220  * page fault on this OS.
221  */
222 static void
223 sigsegv_handler(int signal, siginfo_t *info, void* void_context)
224 {
225     os_context_t *context = arch_os_get_context(&void_context);
226     void* fault_addr = (void*)info->si_addr;
227     if (!gencgc_handle_wp_violation(fault_addr))
228         if(!handle_guard_page_triggered(context,fault_addr))
229 #ifdef LISP_FEATURE_C_STACK_IS_CONTROL_STACK
230             arrange_return_to_lisp_function(context, SymbolFunction(MEMORY_FAULT_ERROR));
231 #else
232             interrupt_handle_now(signal, info, context);
233 #endif
234 }
235
236 #else
237
238 static void
239 sigsegv_handler(int signal, siginfo_t *info, void* void_context)
240 {
241     os_context_t *context = arch_os_get_context(&void_context);
242     os_vm_address_t addr = arch_get_bad_addr(signal,info,context);
243
244 #ifdef LISP_FEATURE_ALPHA
245     /* Alpha stuff: This is the end of a pseudo-atomic section during
246        which a signal was received.  We must deal with the pending
247        interrupt (see also interrupt.c, ../code/interrupt.lisp)
248
249        (how we got here: when interrupting, we set bit 63 in reg_ALLOC.
250        At the end of the atomic section we tried to write to reg_ALLOC,
251        got a SIGSEGV (there's nothing mapped there) so ended up here. */
252     if (addr != NULL &&
253         *os_context_register_addr(context,reg_ALLOC) & (1L<<63)){
254         *os_context_register_addr(context,reg_ALLOC) -= (1L<<63);
255         interrupt_handle_pending(context);
256         return;
257     }
258 #endif
259
260     if(!interrupt_maybe_gc(signal, info, context))
261         if(!handle_guard_page_triggered(context,addr))
262             interrupt_handle_now(signal, info, context);
263 }
264 #endif
265
266 void
267 os_install_interrupt_handlers(void)
268 {
269     undoably_install_low_level_interrupt_handler(SIG_MEMORY_FAULT,
270                                                  sigsegv_handler);
271 #ifdef LISP_FEATURE_SB_THREAD
272     undoably_install_low_level_interrupt_handler(SIG_INTERRUPT_THREAD,
273                                                  interrupt_thread_handler);
274     undoably_install_low_level_interrupt_handler(SIG_STOP_FOR_GC,
275                                                  sig_stop_for_gc_handler);
276 #endif
277 }
278
279 #ifdef LISP_FEATURE_SB_THREAD
280 int
281 futex_wait(int *lock_word, int oldval)
282 {
283     int t= sys_futex(lock_word,FUTEX_WAIT,oldval, 0);
284     return t;
285 }
286
287 int
288 futex_wake(int *lock_word, int n)
289 {
290     return sys_futex(lock_word,FUTEX_WAKE,n,0);
291 }
292 #endif