1 #ifdef LISP_FEATURE_SB_THREAD
2 #include <architecture/i386/table.h>
3 #include <i386/user_ldt.h>
4 #include <mach/mach_init.h>
10 #include "interrupt.h"
11 #include "x86-64-darwin-os.h"
12 #include "genesis/fdefn.h"
14 #include <mach/mach.h>
15 #include <mach/mach_error.h>
16 #include <mach/mach_types.h>
17 #include <mach/sync_policy.h>
18 #include <mach/machine/thread_state.h>
19 #include <mach/machine/thread_status.h>
20 #include <sys/_types.h>
21 #include <sys/ucontext.h>
28 #include <sys/_structs.h>
33 typedef struct __darwin_ucontext darwin_ucontext
;
34 typedef struct __darwin_mcontext64 darwin_mcontext
;
47 #define faultvaddr __faultvaddr
52 #define fpu_fcw __fpu_fcw
53 #define fpu_mxcsr __fpu_mxcsr
57 typedef struct ucontext darwin_ucontext
;
58 typedef struct mcontext darwin_mcontext
;
62 #ifdef LISP_FEATURE_SB_THREAD
63 pthread_mutex_t mach_exception_lock
= PTHREAD_MUTEX_INITIALIZER
;
66 #ifdef LISP_FEATURE_MACH_EXCEPTION_HANDLER
68 void sigill_handler(int signal
, siginfo_t
*siginfo
, os_context_t
*context
);
69 void sigtrap_handler(int signal
, siginfo_t
*siginfo
, os_context_t
*context
);
70 void memory_fault_handler(int signal
, siginfo_t
*siginfo
,
71 os_context_t
*context
);
73 /* This executes in the faulting thread as part of the signal
74 * emulation. It is passed a context with the uc_mcontext field
75 * pointing to a valid block of memory. */
76 void build_fake_signal_context(darwin_ucontext
*context
,
77 x86_thread_state64_t
*thread_state
,
78 x86_float_state64_t
*float_state
) {
79 pthread_sigmask(0, NULL
, &context
->uc_sigmask
);
80 context
->uc_mcontext
->ss
= *thread_state
;
81 context
->uc_mcontext
->fs
= *float_state
;
84 /* This executes in the faulting thread as part of the signal
85 * emulation. It is effectively the inverse operation from above. */
86 void update_thread_state_from_context(x86_thread_state64_t
*thread_state
,
87 x86_float_state64_t
*float_state
,
88 darwin_ucontext
*context
) {
89 *thread_state
= context
->uc_mcontext
->ss
;
90 *float_state
= context
->uc_mcontext
->fs
;
91 pthread_sigmask(SIG_SETMASK
, &context
->uc_sigmask
, NULL
);
94 /* Modify a context to push new data on its stack. */
95 void push_context(u64 data
, x86_thread_state64_t
*context
)
99 stack_pointer
= (u64
*) context
->rsp
;
100 *(--stack_pointer
) = data
;
101 context
->rsp
= (u64
) stack_pointer
;
104 void align_context_stack(x86_thread_state64_t
*context
)
106 /* 16byte align the stack (provided that the stack is, as it
107 * should be, 8byte aligned. */
108 while (context
->rsp
& 15) push_context(0, context
);
111 /* Stack allocation starts with a context that has a mod-4 ESP value
112 * and needs to leave a context with a mod-16 ESP that will restore
113 * the old ESP value and other register state when activated. The
114 * first part of this is the recovery trampoline, which loads ESP from
115 * EBP, pops EBP, and returns. */
116 asm(".globl _stack_allocation_recover; \
118 _stack_allocation_recover: \
119 lea -48(%rbp), %rsp; \
129 void open_stack_allocation(x86_thread_state64_t
*context
)
131 void stack_allocation_recover(void);
133 push_context(context
->rip
, context
);
134 push_context(context
->rbp
, context
);
135 context
->rbp
= context
->rsp
;
137 push_context(context
->r9
, context
);
138 push_context(context
->r8
, context
);
139 push_context(context
->rcx
, context
);
140 push_context(context
->rdx
, context
);
141 push_context(context
->rsi
, context
);
142 push_context(context
->rdi
, context
);
144 context
->rip
= (u64
) stack_allocation_recover
;
146 align_context_stack(context
);
149 /* Stack allocation of data starts with a context with a mod-16 ESP
150 * value and reserves some space on it by manipulating the ESP
152 void *stack_allocate(x86_thread_state64_t
*context
, size_t size
)
154 /* round up size to 16byte multiple */
155 size
= (size
+ 15) & -16;
157 context
->rsp
= ((u64
)context
->rsp
) - size
;
159 return (void *)context
->rsp
;
162 /* Arranging to invoke a C function is tricky, as we have to assume
163 * cdecl calling conventions (caller removes args) and x86/darwin
164 * alignment requirements. The simplest way to arrange this,
165 * actually, is to open a new stack allocation.
166 * WARNING!!! THIS DOES NOT PRESERVE REGISTERS! */
167 void call_c_function_in_context(x86_thread_state64_t
*context
,
176 /* Set up to restore stack on exit. */
177 open_stack_allocation(context
);
179 /* Have to keep stack 16byte aligned on x86/darwin. */
180 for (i
= (1 & -nargs
); i
; i
--) {
181 push_context(0, context
);
184 context
->rsp
= ((u64
)context
->rsp
) - nargs
* 8;
185 stack_pointer
= (u64
*)context
->rsp
;
188 if (nargs
> 0) context
->rdi
= va_arg(ap
, u64
);
189 if (nargs
> 1) context
->rsi
= va_arg(ap
, u64
);
190 if (nargs
> 2) context
->rdx
= va_arg(ap
, u64
);
191 if (nargs
> 3) context
->rcx
= va_arg(ap
, u64
);
192 if (nargs
> 4) context
->r8
= va_arg(ap
, u64
);
193 if (nargs
> 5) context
->r9
= va_arg(ap
, u64
);
194 for (i
= 6; i
< nargs
; i
++) {
195 stack_pointer
[i
] = va_arg(ap
, u64
);
199 push_context(context
->rip
, context
);
200 context
->rip
= (u64
) function
;
203 void signal_emulation_wrapper(x86_thread_state64_t
*thread_state
,
204 x86_float_state64_t
*float_state
,
207 void (*handler
)(int, siginfo_t
*, void *))
210 /* CLH: FIXME **NOTE: HACK ALERT!** Ideally, we would allocate
211 * context and regs on the stack as local variables, but this
212 * causes problems for the lisp debugger. When it walks the stack
213 * for a back trace, it sees the 1) address of the local variable
214 * on the stack and thinks that is a frame pointer to a lisp
215 * frame, and, 2) the address of the sap that we alloc'ed in
216 * dynamic space and thinks that is a return address, so it,
217 * heuristicly (and wrongly), chooses that this should be
218 * interpreted as a lisp frame instead of as a C frame.
219 * We can work around this in this case by os_validating the
220 * context (and regs just for symmetry).
223 darwin_ucontext
*context
;
224 darwin_mcontext
*regs
;
226 context
= (darwin_ucontext
*) os_validate(0, sizeof(darwin_ucontext
));
227 regs
= (darwin_mcontext
*) os_validate(0, sizeof(darwin_mcontext
));
228 context
->uc_mcontext
= regs
;
230 /* when BSD signals are fired, they mask they signals in sa_mask
231 which always seem to be the blockable_sigset, for us, so we
233 1) save the current sigmask
234 2) block blockable signals
235 3) call the signal handler
236 4) restore the sigmask */
238 build_fake_signal_context(context
, thread_state
, float_state
);
240 block_blockable_signals(0, 0);
242 handler(signal
, siginfo
, context
);
244 update_thread_state_from_context(thread_state
, float_state
, context
);
246 os_invalidate((os_vm_address_t
)context
, sizeof(darwin_ucontext
));
247 os_invalidate((os_vm_address_t
)regs
, sizeof(darwin_mcontext
));
249 /* Trap to restore the signal context. */
250 asm volatile (".quad 0xffffffffffff0b0f"
251 : : "a" (thread_state
), "b" (float_state
));
254 #if defined DUMP_CONTEXT
255 void dump_context(x86_thread_state64_t
*context
)
260 printf("rax: %08lx rcx: %08lx rdx: %08lx rbx: %08lx\n",
261 context
->rax
, context
->rcx
, context
->rdx
, context
->rbx
);
262 printf("rsp: %08lx rbp: %08lx rsi: %08lx rdi: %08lx\n",
263 context
->rsp
, context
->rbp
, context
->rsi
, context
->rdi
);
264 printf("rip: %08lx eflags: %08lx\n",
265 context
->rip
, context
->rflags
);
266 printf("cs: %04hx ds: %04hx es: %04hx "
267 "ss: %04hx fs: %04hx gs: %04hx\n",
268 context
->cs
, context
->ds
, context
->rs
,
269 context
->ss
, context
->fs
, context
->gs
);
271 stack_pointer
= (u64
*)context
->rsp
;
272 for (i
= 0; i
< 48; i
+=4) {
273 printf("%08x: %08x %08x %08x %08x\n",
274 context
->rsp
+ (i
* 4),
284 control_stack_exhausted_handler(int signal
, siginfo_t
*siginfo
,
285 os_context_t
*context
) {
286 unblock_signals_in_context_and_maybe_warn(context
);
287 arrange_return_to_lisp_function
288 (context
, StaticSymbolFunction(CONTROL_STACK_EXHAUSTED_ERROR
));
292 undefined_alien_handler(int signal
, siginfo_t
*siginfo
, os_context_t
*context
) {
293 arrange_return_to_lisp_function
294 (context
, StaticSymbolFunction(UNDEFINED_ALIEN_VARIABLE_ERROR
));
298 catch_exception_raise(mach_port_t exception_port
,
301 exception_type_t exception
,
302 exception_data_t code_vector
,
303 mach_msg_type_number_t code_count
)
305 kern_return_t ret
, dealloc_ret
;
309 #ifdef LISP_FEATURE_SB_THREAD
310 thread_mutex_lock(&mach_exception_lock
);
313 x86_thread_state64_t thread_state
;
314 mach_msg_type_number_t thread_state_count
= x86_THREAD_STATE64_COUNT
;
316 x86_float_state64_t float_state
;
317 mach_msg_type_number_t float_state_count
= x86_FLOAT_STATE64_COUNT
;
319 x86_exception_state64_t exception_state
;
320 mach_msg_type_number_t exception_state_count
= x86_EXCEPTION_STATE64_COUNT
;
322 x86_thread_state64_t backup_thread_state
;
323 x86_thread_state64_t
*target_thread_state
;
324 x86_float_state64_t
*target_float_state
;
326 os_vm_address_t addr
;
330 FSHOW((stderr
,"/entering catch_exception_raise with exception: %d\n", exception
));
331 th
= *(struct thread
**)exception_port
;
337 ret
= thread_get_state(thread
,
339 (thread_state_t
)&thread_state
,
340 &thread_state_count
);
341 ret
= thread_get_state(thread
,
343 (thread_state_t
)&float_state
,
345 ret
= thread_get_state(thread
,
346 x86_EXCEPTION_STATE64
,
347 (thread_state_t
)&exception_state
,
348 &exception_state_count
);
349 addr
= (void*)exception_state
.faultvaddr
;
350 /* note the os_context hackery here. When the signal handler returns,
351 * it won't go back to what it was doing ... */
352 if(addr
>= CONTROL_STACK_GUARD_PAGE(th
) &&
353 addr
< CONTROL_STACK_GUARD_PAGE(th
) + os_vm_page_size
) {
354 /* We hit the end of the control stack: disable guard page
355 * protection so the error handler has some headroom, protect the
356 * previous page so that we can catch returns from the guard page
358 lower_thread_control_stack_guard_page(th
);
360 backup_thread_state
= thread_state
;
361 open_stack_allocation(&thread_state
);
362 /* Reserve a 256 byte zone for signal handlers
363 * to use on the interrupted thread stack.
365 stack_allocate(&thread_state
, 256);
367 /* Save thread state */
368 target_thread_state
=
369 stack_allocate(&thread_state
, sizeof(*target_thread_state
));
370 (*target_thread_state
) = backup_thread_state
;
372 /* Save float state */
374 stack_allocate(&thread_state
, sizeof(*target_float_state
));
375 (*target_float_state
) = float_state
;
378 siginfo
= stack_allocate(&thread_state
, sizeof(*siginfo
));
379 /* what do we need to put in our fake siginfo? It looks like
380 * the x86 code only uses si_signo and si_adrr. */
381 siginfo
->si_signo
= signal
;
382 siginfo
->si_addr
= (void*)exception_state
.faultvaddr
;
384 call_c_function_in_context(&thread_state
,
385 signal_emulation_wrapper
,
391 control_stack_exhausted_handler
);
393 else if(addr
>= CONTROL_STACK_RETURN_GUARD_PAGE(th
) &&
394 addr
< CONTROL_STACK_RETURN_GUARD_PAGE(th
) + os_vm_page_size
) {
395 /* We're returning from the guard page: reprotect it, and
396 * unprotect this one. This works even if we somehow missed
397 * the return-guard-page, and hit it on our way to new
398 * exhaustion instead. */
399 reset_thread_control_stack_guard_page(th
);
401 else if (addr
>= undefined_alien_address
&&
402 addr
< undefined_alien_address
+ os_vm_page_size
) {
403 backup_thread_state
= thread_state
;
404 open_stack_allocation(&thread_state
);
405 stack_allocate(&thread_state
, 256);
407 /* Save thread state */
408 target_thread_state
=
409 stack_allocate(&thread_state
, sizeof(*target_thread_state
));
410 (*target_thread_state
) = backup_thread_state
;
413 stack_allocate(&thread_state
, sizeof(*target_float_state
));
414 (*target_float_state
) = float_state
;
417 siginfo
= stack_allocate(&thread_state
, sizeof(*siginfo
));
418 /* what do we need to put in our fake siginfo? It looks like
419 * the x86 code only uses si_signo and si_adrr. */
420 siginfo
->si_signo
= signal
;
421 siginfo
->si_addr
= (void*)exception_state
.faultvaddr
;
423 call_c_function_in_context(&thread_state
,
424 signal_emulation_wrapper
,
430 undefined_alien_handler
);
433 backup_thread_state
= thread_state
;
434 open_stack_allocation(&thread_state
);
435 stack_allocate(&thread_state
, 256);
437 /* Save thread state */
438 target_thread_state
=
439 stack_allocate(&thread_state
, sizeof(*target_thread_state
));
440 (*target_thread_state
) = backup_thread_state
;
443 stack_allocate(&thread_state
, sizeof(*target_float_state
));
444 (*target_float_state
) = float_state
;
447 siginfo
= stack_allocate(&thread_state
, sizeof(*siginfo
));
448 /* what do we need to put in our fake siginfo? It looks like
449 * the x86 code only uses si_signo and si_adrr. */
450 siginfo
->si_signo
= signal
;
451 siginfo
->si_addr
= (void*)exception_state
.faultvaddr
;
453 call_c_function_in_context(&thread_state
,
454 signal_emulation_wrapper
,
460 memory_fault_handler
);
462 ret
= thread_set_state(thread
,
464 (thread_state_t
)&thread_state
,
467 ret
= thread_set_state(thread
,
469 (thread_state_t
)&float_state
,
471 #ifdef LISP_FEATURE_SB_THREAD
472 thread_mutex_unlock(&mach_exception_lock
);
477 case EXC_BAD_INSTRUCTION
:
479 ret
= thread_get_state(thread
,
481 (thread_state_t
)&thread_state
,
482 &thread_state_count
);
483 ret
= thread_get_state(thread
,
485 (thread_state_t
)&float_state
,
487 ret
= thread_get_state(thread
,
488 x86_EXCEPTION_STATE64
,
489 (thread_state_t
)&exception_state
,
490 &exception_state_count
);
491 if (0xffffffffffff0b0f == *((u64
*)thread_state
.rip
)) {
492 /* fake sigreturn. */
494 /* When we get here, thread_state.rax is a pointer to a
495 * thread_state to restore. */
496 /* thread_state = *((thread_state_t *)thread_state.rax); */
498 ret
= thread_set_state(thread
,
500 (thread_state_t
) thread_state
.rax
,
504 ret
= thread_set_state(thread
,
506 (thread_state_t
) thread_state
.rbx
,
511 backup_thread_state
= thread_state
;
512 open_stack_allocation(&thread_state
);
513 stack_allocate(&thread_state
, 256);
515 /* Save thread state */
516 target_thread_state
=
517 stack_allocate(&thread_state
, sizeof(*target_thread_state
));
518 (*target_thread_state
) = backup_thread_state
;
521 stack_allocate(&thread_state
, sizeof(*target_float_state
));
522 (*target_float_state
) = float_state
;
525 siginfo
= stack_allocate(&thread_state
, sizeof(*siginfo
));
526 /* what do we need to put in our fake siginfo? It looks like
527 * the x86 code only uses si_signo and si_adrr. */
528 if (*((unsigned short *)target_thread_state
->rip
) == 0x0b0f) {
530 siginfo
->si_signo
= signal
;
531 siginfo
->si_addr
= (void*)exception_state
.faultvaddr
;
532 target_thread_state
->rip
+= 2;
533 call_c_function_in_context(&thread_state
,
534 signal_emulation_wrapper
,
543 siginfo
->si_signo
= signal
;
544 siginfo
->si_addr
= (void*)exception_state
.faultvaddr
;
546 call_c_function_in_context(&thread_state
,
547 signal_emulation_wrapper
,
555 ret
= thread_set_state(thread
,
557 (thread_state_t
)&thread_state
,
559 ret
= thread_set_state(thread
,
561 (thread_state_t
)&float_state
,
564 #ifdef LISP_FEATURE_SB_THREAD
565 thread_mutex_unlock(&mach_exception_lock
);
571 #ifdef LISP_FEATURE_SB_THREAD
572 thread_mutex_unlock(&mach_exception_lock
);
574 ret
= KERN_INVALID_RIGHT
;
577 dealloc_ret
= mach_port_deallocate (current_mach_task
, thread
);
579 lose("mach_port_deallocate (thread) failed with return_code %d\n", dealloc_ret
);
582 dealloc_ret
= mach_port_deallocate (current_mach_task
, task
);
584 lose("mach_port_deallocate (task) failed with return_code %d\n", dealloc_ret
);
591 os_restore_fp_control(os_context_t
*context
)
593 /* KLUDGE: The x87 FPU control word is some nasty bitfield struct
594 * thing. Rather than deal with that, just grab it as a 16-bit
596 unsigned short fpu_control_word
=
597 *((unsigned short *)&context
->uc_mcontext
->fs
.fpu_fcw
);
598 /* reset exception flags and restore control flags on SSE2 FPU */
599 unsigned int temp
= (context
->uc_mcontext
->fs
.fpu_mxcsr
) & ~0x3F;
600 asm ("ldmxcsr %0" : : "m" (temp
));
601 /* same for x87 FPU. */
602 asm ("fldcw %0" : : "m" (fpu_control_word
));