Fix inline fixnum LDB on PowerPC for certain bytespecs
[sbcl.git] / src / runtime / win32-os.c
1 /*
2  * the Win32 incarnation of OS-dependent routines.  See also
3  * $(sbcl_arch)-win32-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 /*
24  * This file was copied from the Linux version of the same, and
25  * likely still has some linuxisms in it have haven't been elimiated
26  * yet.
27  */
28
29 #include <malloc.h>
30 #include <stdio.h>
31 #include <sys/param.h>
32 #include <sys/file.h>
33 #include <io.h>
34 #include "sbcl.h"
35 #include "./signal.h"
36 #include "os.h"
37 #include "arch.h"
38 #include "globals.h"
39 #include "sbcl.h"
40 #include "interrupt.h"
41 #include "interr.h"
42 #include "lispregs.h"
43 #include "runtime.h"
44 #include "alloc.h"
45 #include "genesis/primitive-objects.h"
46 #include "dynbind.h"
47
48 #include <sys/types.h>
49 #include <signal.h>
50 #include <sys/time.h>
51 #include <sys/stat.h>
52 #include <unistd.h>
53
54 #include <math.h>
55 #include <float.h>
56
57 #include <excpt.h>
58
59 #include "validate.h"
60 #include "thread.h"
61 size_t os_vm_page_size;
62
63 #include "gc.h"
64 #include "gencgc-internal.h"
65
66 #if 0
67 int linux_sparc_siginfo_bug = 0;
68 int linux_supports_futex=0;
69 #endif
70
71 /* The exception handling function looks like this: */
72 EXCEPTION_DISPOSITION handle_exception(EXCEPTION_RECORD *,
73                                        struct lisp_exception_frame *,
74                                        CONTEXT *,
75                                        void *);
76
77 void *base_seh_frame;
78
79 static void *get_seh_frame(void)
80 {
81     void* retval;
82     asm volatile ("movl %%fs:0,%0": "=r" (retval));
83     return retval;
84 }
85
86 static void set_seh_frame(void *frame)
87 {
88     asm volatile ("movl %0,%%fs:0": : "r" (frame));
89 }
90
91 #if 0
92 static struct lisp_exception_frame *find_our_seh_frame(void)
93 {
94     struct lisp_exception_frame *frame = get_seh_frame();
95
96     while (frame->handler != handle_exception)
97         frame = frame->next_frame;
98
99     return frame;
100 }
101
102 inline static void *get_stack_frame(void)
103 {
104     void* retval;
105     asm volatile ("movl %%ebp,%0": "=r" (retval));
106     return retval;
107 }
108 #endif
109
110 void os_init(char *argv[], char *envp[])
111 {
112     SYSTEM_INFO system_info;
113
114     GetSystemInfo(&system_info);
115     os_vm_page_size = system_info.dwPageSize;
116
117     base_seh_frame = get_seh_frame();
118 }
119
120
121 /*
122  * So we have three fun scenarios here.
123  *
124  * First, we could be being called to reserve the memory areas
125  * during initialization (prior to loading the core file).
126  *
127  * Second, we could be being called by the GC to commit a page
128  * that has just been decommitted (for easy zero-fill).
129  *
130  * Third, we could be being called by create_thread_struct()
131  * in order to create the sundry and various stacks.
132  *
133  * The third case is easy to pick out because it passes an
134  * addr of 0.
135  *
136  * The second case is easy to pick out because it will be for
137  * a range of memory that is MEM_RESERVE rather than MEM_FREE.
138  *
139  * The second case is also an easy implement, because we leave
140  * the memory as reserved (since we do lazy commits).
141  */
142
143 os_vm_address_t
144 os_validate(os_vm_address_t addr, os_vm_size_t len)
145 {
146     MEMORY_BASIC_INFORMATION mem_info;
147
148     if (!addr) {
149         /* the simple case first */
150         os_vm_address_t real_addr;
151         if (!(real_addr = VirtualAlloc(addr, len, MEM_COMMIT, PAGE_EXECUTE_READWRITE))) {
152             fprintf(stderr, "VirtualAlloc: 0x%lx.\n", GetLastError());
153             return 0;
154         }
155
156         return real_addr;
157     }
158
159     if (!VirtualQuery(addr, &mem_info, sizeof mem_info)) {
160         fprintf(stderr, "VirtualQuery: 0x%lx.\n", GetLastError());
161         return 0;
162     }
163
164     if ((mem_info.State == MEM_RESERVE) && (mem_info.RegionSize >=len)) {
165       /* It would be correct to return here. However, support for Wine
166        * is beneficial, and Wine has a strange behavior in this
167        * department. It reports all memory below KERNEL32.DLL as
168        * reserved, but disallows MEM_COMMIT.
169        *
170        * Let's work around it: reserve the region we need for a second
171        * time. The second reservation is documented to fail on normal NT
172        * family, but it will succeed on Wine if this region is
173        * actually free.
174        */
175       VirtualAlloc(addr, len, MEM_RESERVE, PAGE_EXECUTE_READWRITE);
176       /* If it is wine, the second call has succeded, and now the region
177        * is really reserved. */
178       return addr;
179     }
180
181     if (mem_info.State == MEM_RESERVE) {
182         fprintf(stderr, "validation of reserved space too short.\n");
183         fflush(stderr);
184     }
185
186     if (!VirtualAlloc(addr, len, (mem_info.State == MEM_RESERVE)? MEM_COMMIT: MEM_RESERVE, PAGE_EXECUTE_READWRITE)) {
187         fprintf(stderr, "VirtualAlloc: 0x%lx.\n", GetLastError());
188         return 0;
189     }
190
191     return addr;
192 }
193
194 /*
195  * For os_invalidate(), we merely decommit the memory rather than
196  * freeing the address space. This loses when freeing per-thread
197  * data and related memory since it leaks address space. It's not
198  * too lossy, however, since the two scenarios I'm aware of are
199  * fd-stream buffers, which are pooled rather than torched, and
200  * thread information, which I hope to pool (since windows creates
201  * threads at its own whim, and we probably want to be able to
202  * have them callback without funky magic on the part of the user,
203  * and full-on thread allocation is fairly heavyweight). Someone
204  * will probably shoot me down on this with some pithy comment on
205  * the use of (setf symbol-value) on a special variable. I'm happy
206  * for them.
207  */
208
209 void
210 os_invalidate(os_vm_address_t addr, os_vm_size_t len)
211 {
212     if (!VirtualFree(addr, len, MEM_DECOMMIT)) {
213         fprintf(stderr, "VirtualFree: 0x%lx.\n", GetLastError());
214     }
215 }
216
217 /*
218  * os_map() is called to map a chunk of the core file into memory.
219  *
220  * Unfortunately, Windows semantics completely screws this up, so
221  * we just add backing store from the swapfile to where the chunk
222  * goes and read it up like a normal file. We could consider using
223  * a lazy read (demand page) setup, but that would mean keeping an
224  * open file pointer for the core indefinately (and be one more
225  * thing to maintain).
226  */
227
228 os_vm_address_t
229 os_map(int fd, int offset, os_vm_address_t addr, os_vm_size_t len)
230 {
231     os_vm_size_t count;
232
233 #if 0
234     fprintf(stderr, "os_map: %d, 0x%x, %p, 0x%x.\n", fd, offset, addr, len);
235     fflush(stderr);
236 #endif
237
238     if (!VirtualAlloc(addr, len, MEM_COMMIT, PAGE_EXECUTE_READWRITE)) {
239         fprintf(stderr, "VirtualAlloc: 0x%lx.\n", GetLastError());
240         lose("os_map: VirtualAlloc failure");
241     }
242
243     if (lseek(fd, offset, SEEK_SET) == -1) {
244         lose("os_map: Seek failure.");
245     }
246
247     count = read(fd, addr, len);
248     if (count != len) {
249         fprintf(stderr, "expected 0x%x, read 0x%x.\n", len, count);
250         lose("os_map: Failed to read enough bytes.");
251     }
252
253     return addr;
254 }
255
256 static DWORD os_protect_modes[8] = {
257     PAGE_NOACCESS,
258     PAGE_READONLY,
259     PAGE_READWRITE,
260     PAGE_READWRITE,
261     PAGE_EXECUTE,
262     PAGE_EXECUTE_READ,
263     PAGE_EXECUTE_READWRITE,
264     PAGE_EXECUTE_READWRITE,
265 };
266
267 void
268 os_protect(os_vm_address_t address, os_vm_size_t length, os_vm_prot_t prot)
269 {
270     DWORD old_prot;
271
272     if (!VirtualProtect(address, length, os_protect_modes[prot], &old_prot)) {
273         fprintf(stderr, "VirtualProtect failed, code 0x%lx.\n", GetLastError());
274         fflush(stderr);
275     }
276 }
277
278 /* FIXME: Now that FOO_END, rather than FOO_SIZE, is the fundamental
279  * description of a space, we could probably punt this and just do
280  * (FOO_START <= x && x < FOO_END) everywhere it's called. */
281 static boolean
282 in_range_p(os_vm_address_t a, lispobj sbeg, size_t slen)
283 {
284     char* beg = (char*)((long)sbeg);
285     char* end = (char*)((long)sbeg) + slen;
286     char* adr = (char*)a;
287     return (adr >= beg && adr < end);
288 }
289
290 boolean
291 is_linkage_table_addr(os_vm_address_t addr)
292 {
293     return in_range_p(addr, LINKAGE_TABLE_SPACE_START, LINKAGE_TABLE_SPACE_END);
294 }
295
296 boolean
297 is_valid_lisp_addr(os_vm_address_t addr)
298 {
299     struct thread *th;
300     if(in_range_p(addr, READ_ONLY_SPACE_START, READ_ONLY_SPACE_SIZE) ||
301        in_range_p(addr, STATIC_SPACE_START   , STATIC_SPACE_SIZE) ||
302        in_range_p(addr, DYNAMIC_SPACE_START  , dynamic_space_size))
303         return 1;
304     for_each_thread(th) {
305         if(((os_vm_address_t)th->control_stack_start <= addr) && (addr < (os_vm_address_t)th->control_stack_end))
306             return 1;
307         if(in_range_p(addr, (unsigned long)th->binding_stack_start, BINDING_STACK_SIZE))
308             return 1;
309     }
310     return 0;
311 }
312
313 /* A tiny bit of interrupt.c state we want our paws on. */
314 extern boolean internal_errors_enabled;
315
316 #ifdef LISP_FEATURE_UD2_BREAKPOINTS
317 #define IS_TRAP_EXCEPTION(exception_record, context) \
318     (((exception_record)->ExceptionCode == EXCEPTION_ILLEGAL_INSTRUCTION) && \
319      (((unsigned short *)((context)->Eip))[0] == 0x0b0f))
320 #define TRAP_CODE_WIDTH 2
321 #else
322 #define IS_TRAP_EXCEPTION(exception_record, context) \
323     ((exception_record)->ExceptionCode == EXCEPTION_BREAKPOINT)
324 #define TRAP_CODE_WIDTH 1
325 #endif
326
327 /*
328  * A good explanation of the exception handling semantics is
329  * http://win32assembly.online.fr/Exceptionhandling.html .
330  */
331
332 EXCEPTION_DISPOSITION
333 handle_exception(EXCEPTION_RECORD *exception_record,
334                  struct lisp_exception_frame *exception_frame,
335                  CONTEXT *context,
336                  void *dispatcher_context)
337 {
338     if (exception_record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND)) {
339         /* If we're being unwound, be graceful about it. */
340
341         /* Undo any dynamic bindings. */
342         unbind_to_here(exception_frame->bindstack_pointer,
343                        arch_os_get_current_thread());
344
345         return ExceptionContinueSearch;
346     }
347
348     /* For EXCEPTION_ACCESS_VIOLATION only. */
349     void *fault_address = (void *)exception_record->ExceptionInformation[1];
350
351     if (single_stepping &&
352         exception_record->ExceptionCode == EXCEPTION_SINGLE_STEP) {
353         /* We are doing a displaced instruction. At least function
354          * end breakpoints uses this. */
355         restore_breakpoint_from_single_step(context);
356         return ExceptionContinueExecution;
357     }
358
359     if (IS_TRAP_EXCEPTION(exception_record, context)) {
360         unsigned char trap;
361         /* This is just for info in case the monitor wants to print an
362          * approximation. */
363         current_control_stack_pointer =
364             (lispobj *)*os_context_sp_addr(context);
365         /* Unlike some other operating systems, Win32 leaves EIP
366          * pointing to the breakpoint instruction. */
367         context->Eip += TRAP_CODE_WIDTH;
368         /* Now EIP points just after the INT3 byte and aims at the
369          * 'kind' value (eg trap_Cerror). */
370         trap = *(unsigned char *)(*os_context_pc_addr(context));
371         handle_trap(context, trap);
372         /* Done, we're good to go! */
373         return ExceptionContinueExecution;
374     }
375     else if (exception_record->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
376              (is_valid_lisp_addr(fault_address) ||
377               is_linkage_table_addr(fault_address))) {
378         /* Pick off GC-related memory fault next. */
379         MEMORY_BASIC_INFORMATION mem_info;
380
381         if (!VirtualQuery(fault_address, &mem_info, sizeof mem_info)) {
382             fprintf(stderr, "VirtualQuery: 0x%lx.\n", GetLastError());
383             lose("handle_exception: VirtualQuery failure");
384         }
385
386         if (mem_info.State == MEM_RESERVE) {
387             /* First use new page, lets get some memory for it. */
388             if (!VirtualAlloc(mem_info.BaseAddress, os_vm_page_size,
389                               MEM_COMMIT, PAGE_EXECUTE_READWRITE)) {
390                 fprintf(stderr, "VirtualAlloc: 0x%lx.\n", GetLastError());
391                 lose("handle_exception: VirtualAlloc failure");
392
393             } else {
394                 /*
395                  * Now, if the page is supposedly write-protected and this
396                  * is a write, tell the gc that it's been hit.
397                  *
398                  * FIXME: Are we supposed to fall-through to the Lisp
399                  * exception handler if the gc doesn't take the wp violation?
400                  */
401                 if (exception_record->ExceptionInformation[0]) {
402                     page_index_t index = find_page_index(fault_address);
403                     if ((index != -1) && (page_table[index].write_protected)) {
404                         gencgc_handle_wp_violation(fault_address);
405                     }
406                 }
407                 return ExceptionContinueExecution;
408             }
409
410         } else if (gencgc_handle_wp_violation(fault_address)) {
411             /* gc accepts the wp violation, so resume where we left off. */
412             return ExceptionContinueExecution;
413         }
414
415         /* All else failed, drop through to the lisp-side exception handler. */
416     }
417
418     /*
419      * If we fall through to here then we need to either forward
420      * the exception to the lisp-side exception handler if it's
421      * set up, or drop to LDB.
422      */
423
424     if (internal_errors_enabled) {
425         lispobj context_sap;
426         lispobj exception_record_sap;
427
428         /* We're making the somewhat arbitrary decision that having
429          * internal errors enabled means that lisp has sufficient
430          * marbles to be able to handle exceptions, but exceptions
431          * aren't supposed to happen during cold init or reinit
432          * anyway. */
433
434         fake_foreign_function_call(context);
435
436         /* Allocate the SAP objects while the "interrupts" are still
437          * disabled. */
438         context_sap = alloc_sap(context);
439         exception_record_sap = alloc_sap(exception_record);
440
441         /* The exception system doesn't automatically clear pending
442          * exceptions, so we lose as soon as we execute any FP
443          * instruction unless we do this first. */
444         _clearfp();
445
446         /* Call into lisp to handle things. */
447         funcall2(StaticSymbolFunction(HANDLE_WIN32_EXCEPTION), context_sap,
448                  exception_record_sap);
449
450         /* If Lisp doesn't nlx, we need to put things back. */
451         undo_fake_foreign_function_call(context);
452
453         /* FIXME: HANDLE-WIN32-EXCEPTION should be allowed to decline */
454         return ExceptionContinueExecution;
455     }
456
457     fprintf(stderr, "Exception Code: 0x%lx.\n", exception_record->ExceptionCode);
458     fprintf(stderr, "Faulting IP: 0x%lx.\n", (DWORD)exception_record->ExceptionAddress);
459     if (exception_record->ExceptionCode == EXCEPTION_ACCESS_VIOLATION) {
460         MEMORY_BASIC_INFORMATION mem_info;
461
462         if (VirtualQuery(fault_address, &mem_info, sizeof mem_info)) {
463             fprintf(stderr, "page status: 0x%lx.\n", mem_info.State);
464         }
465
466         fprintf(stderr, "Was writing: %ld, where: 0x%lx.\n",
467                 exception_record->ExceptionInformation[0],
468                 (DWORD)fault_address);
469     }
470
471     fflush(stderr);
472
473     fake_foreign_function_call(context);
474     lose("Exception too early in cold init, cannot continue.");
475
476     /* FIXME: WTF? How are we supposed to end up here? */
477     return ExceptionContinueSearch;
478 }
479
480 void
481 wos_install_interrupt_handlers(struct lisp_exception_frame *handler)
482 {
483     handler->next_frame = get_seh_frame();
484     handler->handler = &handle_exception;
485     set_seh_frame(handler);
486 }
487
488 void bcopy(const void *src, void *dest, size_t n)
489 {
490     MoveMemory(dest, src, n);
491 }
492
493 /*
494  * The stubs below are replacements for the windows versions,
495  * which can -fail- when used in our memory spaces because they
496  * validate the memory spaces they are passed in a way that
497  * denies our exception handler a chance to run.
498  */
499
500 void *memmove(void *dest, const void *src, size_t n)
501 {
502     if (dest < src) {
503         int i;
504         for (i = 0; i < n; i++) *(((char *)dest)+i) = *(((char *)src)+i);
505     } else {
506         while (n--) *(((char *)dest)+n) = *(((char *)src)+n);
507     }
508     return dest;
509 }
510
511 void *memcpy(void *dest, const void *src, size_t n)
512 {
513     while (n--) *(((char *)dest)+n) = *(((char *)src)+n);
514     return dest;
515 }
516
517 char *dirname(char *path)
518 {
519     static char buf[PATH_MAX + 1];
520     size_t pathlen = strlen(path);
521     int i;
522
523     if (pathlen >= sizeof(buf)) {
524         lose("Pathname too long in dirname.\n");
525         return NULL;
526     }
527
528     strcpy(buf, path);
529     for (i = pathlen; i >= 0; --i) {
530         if (buf[i] == '/' || buf[i] == '\\') {
531             buf[i] = '\0';
532             break;
533         }
534     }
535
536     return buf;
537 }
538
539 /* This is a manually-maintained version of ldso_stubs.S. */
540
541 void __stdcall RtlUnwind(void *, void *, void *, void *); /* I don't have winternl.h */
542
543 void scratch(void)
544 {
545     CloseHandle(0);
546     FlushConsoleInputBuffer(0);
547     FormatMessageA(0, 0, 0, 0, 0, 0, 0);
548     FreeLibrary(0);
549     GetACP();
550     GetConsoleCP();
551     GetConsoleOutputCP();
552     GetCurrentProcess();
553     GetExitCodeProcess(0, 0);
554     GetLastError();
555     GetOEMCP();
556     GetProcAddress(0, 0);
557     GetProcessTimes(0, 0, 0, 0, 0);
558     GetSystemTimeAsFileTime(0);
559     LoadLibrary(0);
560     LocalFree(0);
561     PeekConsoleInput(0, 0, 0, 0);
562     PeekNamedPipe(0, 0, 0, 0, 0, 0);
563     ReadFile(0, 0, 0, 0, 0);
564     Sleep(0);
565     WriteFile(0, 0, 0, 0, 0);
566     _get_osfhandle(0);
567     _rmdir(0);
568     _pipe(0,0,0);
569     access(0,0);
570     close(0);
571     dup(0);
572     isatty(0);
573     strerror(42);
574     write(0, 0, 0);
575     RtlUnwind(0, 0, 0, 0);
576     MapViewOfFile(0,0,0,0,0);
577     UnmapViewOfFile(0);
578     FlushViewOfFile(0,0);
579     #ifndef LISP_FEATURE_SB_UNICODE
580       CreateDirectoryA(0,0);
581       CreateFileMappingA(0,0,0,0,0,0);
582       CreateFileA(0,0,0,0,0,0,0);
583       GetComputerNameA(0, 0);
584       GetCurrentDirectoryA(0,0);
585       GetEnvironmentVariableA(0, 0, 0);
586       GetFileAttributesA(0);
587       GetVersionExA(0);
588       MoveFileA(0,0);
589       SHGetFolderPathA(0, 0, 0, 0, 0);
590       SetCurrentDirectoryA(0);
591       SetEnvironmentVariableA(0, 0);
592     #else
593       CreateDirectoryW(0,0);
594       CreateFileMappingW(0,0,0,0,0,0);
595       CreateFileW(0,0,0,0,0,0,0);
596       FormatMessageW(0, 0, 0, 0, 0, 0, 0);
597       GetComputerNameW(0, 0);
598       GetCurrentDirectoryW(0,0);
599       GetEnvironmentVariableW(0, 0, 0);
600       GetFileAttributesW(0);
601       GetVersionExW(0);
602       MoveFileW(0,0);
603       SHGetFolderPathW(0, 0, 0, 0, 0);
604       SetCurrentDirectoryW(0);
605       SetEnvironmentVariableW(0, 0);
606     #endif
607     _exit(0);
608 }
609
610 char *
611 os_get_runtime_executable_path(int external)
612 {
613     char path[MAX_PATH + 1];
614     DWORD bufsize = sizeof(path);
615     DWORD size;
616
617     if ((size = GetModuleFileNameA(NULL, path, bufsize)) == 0)
618         return NULL;
619     else if (size == bufsize && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
620         return NULL;
621
622     return copied_string(path);
623 }
624
625 /* EOF */