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
54 typedef struct ucontext darwin_ucontext;
55 typedef struct mcontext darwin_mcontext;
59 #ifdef LISP_FEATURE_SB_THREAD
60 pthread_mutex_t mach_exception_lock = PTHREAD_MUTEX_INITIALIZER;
63 #ifdef LISP_FEATURE_MACH_EXCEPTION_HANDLER
65 kern_return_t mach_thread_init(mach_port_t thread_exception_port);
67 void sigill_handler(int signal, siginfo_t *siginfo, os_context_t *context);
68 void sigtrap_handler(int signal, siginfo_t *siginfo, os_context_t *context);
69 void memory_fault_handler(int signal, siginfo_t *siginfo,
70 os_context_t *context);
72 /* exc_server handles mach exception messages from the kernel and
73 * calls catch exception raise. We use the system-provided
74 * mach_msg_server, which, I assume, calls exc_server in a loop.
77 extern boolean_t exc_server();
79 /* This executes in the faulting thread as part of the signal
80 * emulation. It is passed a context with the uc_mcontext field
81 * pointing to a valid block of memory. */
82 void build_fake_signal_context(darwin_ucontext *context,
83 x86_thread_state64_t *thread_state,
84 x86_float_state64_t *float_state) {
85 pthread_sigmask(0, NULL, &context->uc_sigmask);
86 context->uc_mcontext->ss = *thread_state;
87 context->uc_mcontext->fs = *float_state;
90 /* This executes in the faulting thread as part of the signal
91 * emulation. It is effectively the inverse operation from above. */
92 void update_thread_state_from_context(x86_thread_state64_t *thread_state,
93 x86_float_state64_t *float_state,
94 darwin_ucontext *context) {
95 *thread_state = context->uc_mcontext->ss;
96 *float_state = context->uc_mcontext->fs;
97 pthread_sigmask(SIG_SETMASK, &context->uc_sigmask, NULL);
100 /* Modify a context to push new data on its stack. */
101 void push_context(u64 data, x86_thread_state64_t *context)
105 stack_pointer = (u64*) context->rsp;
106 *(--stack_pointer) = data;
107 context->rsp = (u64) stack_pointer;
110 void align_context_stack(x86_thread_state64_t *context)
112 /* 16byte align the stack (provided that the stack is, as it
113 * should be, 8byte aligned. */
114 while (context->rsp & 15) push_context(0, context);
117 /* Stack allocation starts with a context that has a mod-4 ESP value
118 * and needs to leave a context with a mod-16 ESP that will restore
119 * the old ESP value and other register state when activated. The
120 * first part of this is the recovery trampoline, which loads ESP from
121 * EBP, pops EBP, and returns. */
122 asm(".globl _stack_allocation_recover; .align 4; _stack_allocation_recover: mov %rbp, %rsp; pop %rsi; pop %rdi; pop \
123 %rdx; pop %rcx; pop %r8; pop %r9; pop %rbp; ret;");
125 void open_stack_allocation(x86_thread_state64_t *context)
127 void stack_allocation_recover(void);
129 push_context(context->rip, context);
130 push_context(context->rbp, context);
132 push_context(context->r9, context);
133 push_context(context->r8, context);
134 push_context(context->rcx, context);
135 push_context(context->rdx, context);
136 push_context(context->rsi, context);
137 push_context(context->rdi, context);
139 context->rbp = context->rsp;
140 context->rip = (u64) stack_allocation_recover;
142 align_context_stack(context);
145 /* Stack allocation of data starts with a context with a mod-16 ESP
146 * value and reserves some space on it by manipulating the ESP
148 void *stack_allocate(x86_thread_state64_t *context, size_t size)
150 /* round up size to 16byte multiple */
151 size = (size + 15) & -16;
153 context->rsp = ((u64)context->rsp) - size;
155 return (void *)context->rsp;
158 /* Arranging to invoke a C function is tricky, as we have to assume
159 * cdecl calling conventions (caller removes args) and x86/darwin
160 * alignment requirements. The simplest way to arrange this,
161 * actually, is to open a new stack allocation.
162 * WARNING!!! THIS DOES NOT PRESERVE REGISTERS! */
163 void call_c_function_in_context(x86_thread_state64_t *context,
172 /* Set up to restore stack on exit. */
173 open_stack_allocation(context);
175 /* Have to keep stack 16byte aligned on x86/darwin. */
176 for (i = (1 & -nargs); i; i--) {
177 push_context(0, context);
180 context->rsp = ((u64)context->rsp) - nargs * 8;
181 stack_pointer = (u64 *)context->rsp;
184 if (nargs > 0) context->rdi = va_arg(ap, u64);
185 if (nargs > 1) context->rsi = va_arg(ap, u64);
186 if (nargs > 2) context->rdx = va_arg(ap, u64);
187 if (nargs > 3) context->rcx = va_arg(ap, u64);
188 if (nargs > 4) context->r8 = va_arg(ap, u64);
189 if (nargs > 5) context->r9 = va_arg(ap, u64);
190 for (i = 6; i < nargs; i++) {
191 stack_pointer[i] = va_arg(ap, u64);
195 push_context(context->rip, context);
196 context->rip = (u64) function;
199 void signal_emulation_wrapper(x86_thread_state64_t *thread_state,
200 x86_float_state64_t *float_state,
203 void (*handler)(int, siginfo_t *, void *))
206 /* CLH: FIXME **NOTE: HACK ALERT!** Ideally, we would allocate
207 * context and regs on the stack as local variables, but this
208 * causes problems for the lisp debugger. When it walks the stack
209 * for a back trace, it sees the 1) address of the local variable
210 * on the stack and thinks that is a frame pointer to a lisp
211 * frame, and, 2) the address of the sap that we alloc'ed in
212 * dynamic space and thinks that is a return address, so it,
213 * heuristicly (and wrongly), chooses that this should be
214 * interpreted as a lisp frame instead of as a C frame.
215 * We can work around this in this case by os_validating the
216 * context (and regs just for symmetry).
219 darwin_ucontext *context;
220 darwin_mcontext *regs;
222 context = (darwin_ucontext *) os_validate(0, sizeof(darwin_ucontext));
223 regs = (darwin_mcontext*) os_validate(0, sizeof(darwin_mcontext));
224 context->uc_mcontext = regs;
226 /* when BSD signals are fired, they mask they signals in sa_mask
227 which always seem to be the blockable_sigset, for us, so we
229 1) save the current sigmask
230 2) block blockable signals
231 3) call the signal handler
232 4) restore the sigmask */
234 build_fake_signal_context(context, thread_state, float_state);
236 block_blockable_signals(0, 0);
238 handler(signal, siginfo, context);
240 update_thread_state_from_context(thread_state, float_state, context);
242 os_invalidate((os_vm_address_t)context, sizeof(darwin_ucontext));
243 os_invalidate((os_vm_address_t)regs, sizeof(darwin_mcontext));
245 /* Trap to restore the signal context. */
246 asm volatile ("mov %0, %%rax; mov %1, %%rbx; .quad 0xffffffffffff0b0f"
247 : : "r" (thread_state), "r" (float_state));
250 #if defined DUMP_CONTEXT
251 void dump_context(x86_thread_state64_t *context)
256 printf("rax: %08lx rcx: %08lx rdx: %08lx rbx: %08lx\n",
257 context->rax, context->rcx, context->rdx, context->rbx);
258 printf("rsp: %08lx rbp: %08lx rsi: %08lx rdi: %08lx\n",
259 context->rsp, context->rbp, context->rsi, context->rdi);
260 printf("rip: %08lx eflags: %08lx\n",
261 context->rip, context->rflags);
262 printf("cs: %04hx ds: %04hx es: %04hx "
263 "ss: %04hx fs: %04hx gs: %04hx\n",
264 context->cs, context->ds, context->rs,
265 context->ss, context->fs, context->gs);
267 stack_pointer = (u64 *)context->rsp;
268 for (i = 0; i < 48; i+=4) {
269 printf("%08x: %08x %08x %08x %08x\n",
270 context->rsp + (i * 4),
280 control_stack_exhausted_handler(int signal, siginfo_t *siginfo,
281 os_context_t *context) {
282 unblock_signals_in_context_and_maybe_warn(context);
283 arrange_return_to_lisp_function
284 (context, StaticSymbolFunction(CONTROL_STACK_EXHAUSTED_ERROR));
288 undefined_alien_handler(int signal, siginfo_t *siginfo, os_context_t *context) {
289 arrange_return_to_lisp_function
290 (context, StaticSymbolFunction(UNDEFINED_ALIEN_VARIABLE_ERROR));
294 catch_exception_raise(mach_port_t exception_port,
297 exception_type_t exception,
298 exception_data_t code_vector,
299 mach_msg_type_number_t code_count)
305 #ifdef LISP_FEATURE_SB_THREAD
306 thread_mutex_lock(&mach_exception_lock);
309 x86_thread_state64_t thread_state;
310 mach_msg_type_number_t thread_state_count = x86_THREAD_STATE64_COUNT;
312 x86_float_state64_t float_state;
313 mach_msg_type_number_t float_state_count = x86_FLOAT_STATE64_COUNT;
315 x86_exception_state64_t exception_state;
316 mach_msg_type_number_t exception_state_count = x86_EXCEPTION_STATE64_COUNT;
318 x86_thread_state64_t backup_thread_state;
319 x86_thread_state64_t *target_thread_state;
320 x86_float_state64_t *target_float_state;
322 os_vm_address_t addr;
324 struct thread *th = (struct thread*) exception_port;
326 FSHOW((stderr,"/entering catch_exception_raise with exception: %d\n", exception));
332 ret = thread_get_state(thread,
334 (thread_state_t)&thread_state,
335 &thread_state_count);
336 ret = thread_get_state(thread,
338 (thread_state_t)&float_state,
340 ret = thread_get_state(thread,
341 x86_EXCEPTION_STATE64,
342 (thread_state_t)&exception_state,
343 &exception_state_count);
344 addr = (void*)exception_state.faultvaddr;
347 /* note the os_context hackery here. When the signal handler returns,
348 * it won't go back to what it was doing ... */
349 if(addr >= CONTROL_STACK_GUARD_PAGE(th) &&
350 addr < CONTROL_STACK_GUARD_PAGE(th) + os_vm_page_size) {
351 /* We hit the end of the control stack: disable guard page
352 * protection so the error handler has some headroom, protect the
353 * previous page so that we can catch returns from the guard page
355 protect_control_stack_guard_page(0, th);
356 protect_control_stack_return_guard_page(1, th);
358 backup_thread_state = thread_state;
359 open_stack_allocation(&thread_state);
360 /* Reserve a 256 byte zone for signal handlers
361 * to use on the interrupted thread stack.
363 stack_allocate(&thread_state, 256);
365 /* Save thread state */
366 target_thread_state =
367 stack_allocate(&thread_state, sizeof(*target_thread_state));
368 (*target_thread_state) = backup_thread_state;
370 /* Save float state */
372 stack_allocate(&thread_state, sizeof(*target_float_state));
373 (*target_float_state) = float_state;
376 siginfo = stack_allocate(&thread_state, sizeof(*siginfo));
377 /* what do we need to put in our fake siginfo? It looks like
378 * the x86 code only uses si_signo and si_adrr. */
379 siginfo->si_signo = signal;
380 siginfo->si_addr = (void*)exception_state.faultvaddr;
382 call_c_function_in_context(&thread_state,
383 signal_emulation_wrapper,
389 control_stack_exhausted_handler);
391 else if(addr >= CONTROL_STACK_RETURN_GUARD_PAGE(th) &&
392 addr < CONTROL_STACK_RETURN_GUARD_PAGE(th) + os_vm_page_size) {
393 /* We're returning from the guard page: reprotect it, and
394 * unprotect this one. This works even if we somehow missed
395 * the return-guard-page, and hit it on our way to new
396 * exhaustion instead. */
397 protect_control_stack_guard_page(1, th);
398 protect_control_stack_return_guard_page(0, th);
400 else if (addr >= undefined_alien_address &&
401 addr < undefined_alien_address + os_vm_page_size) {
402 backup_thread_state = thread_state;
403 open_stack_allocation(&thread_state);
404 stack_allocate(&thread_state, 256);
406 /* Save thread state */
407 target_thread_state =
408 stack_allocate(&thread_state, sizeof(*target_thread_state));
409 (*target_thread_state) = backup_thread_state;
412 stack_allocate(&thread_state, sizeof(*target_float_state));
413 (*target_float_state) = float_state;
416 siginfo = stack_allocate(&thread_state, sizeof(*siginfo));
417 /* what do we need to put in our fake siginfo? It looks like
418 * the x86 code only uses si_signo and si_adrr. */
419 siginfo->si_signo = signal;
420 siginfo->si_addr = (void*)exception_state.faultvaddr;
422 call_c_function_in_context(&thread_state,
423 signal_emulation_wrapper,
429 undefined_alien_handler);
432 backup_thread_state = thread_state;
433 open_stack_allocation(&thread_state);
434 stack_allocate(&thread_state, 256);
436 /* Save thread state */
437 target_thread_state =
438 stack_allocate(&thread_state, sizeof(*target_thread_state));
439 (*target_thread_state) = backup_thread_state;
442 stack_allocate(&thread_state, sizeof(*target_float_state));
443 (*target_float_state) = float_state;
446 siginfo = stack_allocate(&thread_state, sizeof(*siginfo));
447 /* what do we need to put in our fake siginfo? It looks like
448 * the x86 code only uses si_signo and si_adrr. */
449 siginfo->si_signo = signal;
450 siginfo->si_addr = (void*)exception_state.faultvaddr;
452 call_c_function_in_context(&thread_state,
453 signal_emulation_wrapper,
459 memory_fault_handler);
461 ret = thread_set_state(thread,
463 (thread_state_t)&thread_state,
466 ret = thread_set_state(thread,
468 (thread_state_t)&float_state,
470 #ifdef LISP_FEATURE_SB_THREAD
471 thread_mutex_unlock(&mach_exception_lock);
475 case EXC_BAD_INSTRUCTION:
477 ret = thread_get_state(thread,
479 (thread_state_t)&thread_state,
480 &thread_state_count);
481 ret = thread_get_state(thread,
483 (thread_state_t)&float_state,
485 ret = thread_get_state(thread,
486 x86_EXCEPTION_STATE64,
487 (thread_state_t)&exception_state,
488 &exception_state_count);
489 if (0xffffffffffff0b0f == *((u64 *)thread_state.rip)) {
490 /* fake sigreturn. */
492 /* When we get here, thread_state.rax is a pointer to a
493 * thread_state to restore. */
494 /* thread_state = *((thread_state_t *)thread_state.rax); */
496 ret = thread_set_state(thread,
498 (thread_state_t) thread_state.rax,
502 ret = thread_set_state(thread,
504 (thread_state_t) thread_state.rbx,
509 backup_thread_state = thread_state;
510 open_stack_allocation(&thread_state);
511 stack_allocate(&thread_state, 256);
513 /* Save thread state */
514 target_thread_state =
515 stack_allocate(&thread_state, sizeof(*target_thread_state));
516 (*target_thread_state) = backup_thread_state;
519 stack_allocate(&thread_state, sizeof(*target_float_state));
520 (*target_float_state) = float_state;
523 siginfo = stack_allocate(&thread_state, sizeof(*siginfo));
524 /* what do we need to put in our fake siginfo? It looks like
525 * the x86 code only uses si_signo and si_adrr. */
526 if (*((unsigned short *)target_thread_state->rip) == 0x0b0f) {
528 siginfo->si_signo = signal;
529 siginfo->si_addr = (void*)exception_state.faultvaddr;
530 target_thread_state->rip += 2;
531 call_c_function_in_context(&thread_state,
532 signal_emulation_wrapper,
541 siginfo->si_signo = signal;
542 siginfo->si_addr = (void*)exception_state.faultvaddr;
544 call_c_function_in_context(&thread_state,
545 signal_emulation_wrapper,
553 ret = thread_set_state(thread,
555 (thread_state_t)&thread_state,
557 ret = thread_set_state(thread,
559 (thread_state_t)&float_state,
562 #ifdef LISP_FEATURE_SB_THREAD
563 thread_mutex_unlock(&mach_exception_lock);
568 #ifdef LISP_FEATURE_SB_THREAD
569 thread_mutex_unlock(&mach_exception_lock);
571 return KERN_INVALID_RIGHT;
576 mach_exception_handler(void *port)
578 mach_msg_server(exc_server, 2048, (mach_port_t) port, 0);
579 /* mach_msg_server should never return, but it should dispatch mach
580 * exceptions to our catch_exception_raise function
582 lose("mach_msg_server returned");
585 /* Sets up the thread that will listen for mach exceptions. note that
586 the exception handlers will be run on this thread. This is
587 different from the BSD-style signal handling situation in which the
588 signal handlers run in the relevant thread directly. */
590 mach_port_t mach_exception_handler_port_set = MACH_PORT_NULL;
593 setup_mach_exception_handling_thread()
596 pthread_t mach_exception_handling_thread = NULL;
599 /* allocate a mach_port for this process */
600 ret = mach_port_allocate(mach_task_self(),
601 MACH_PORT_RIGHT_PORT_SET,
602 &mach_exception_handler_port_set);
604 /* create the thread that will receive the mach exceptions */
606 FSHOW((stderr, "Creating mach_exception_handler thread!\n"));
608 pthread_attr_init(&attr);
609 pthread_create(&mach_exception_handling_thread,
611 mach_exception_handler,
612 (void*) mach_exception_handler_port_set);
613 pthread_attr_destroy(&attr);
615 return mach_exception_handling_thread;
618 /* tell the kernel that we want EXC_BAD_ACCESS exceptions sent to the
619 exception port (which is being listened to do by the mach
620 exception handling thread). */
622 mach_thread_init(mach_port_t thread_exception_port)
625 /* allocate a named port for the thread */
627 FSHOW((stderr, "Allocating mach port %x\n", thread_exception_port));
629 ret = mach_port_allocate_name(mach_task_self(),
630 MACH_PORT_RIGHT_RECEIVE,
631 thread_exception_port);
633 lose("mach_port_allocate_name failed with return_code %d\n", ret);
636 /* establish the right for the thread_exception_port to send messages */
637 ret = mach_port_insert_right(mach_task_self(),
638 thread_exception_port,
639 thread_exception_port,
640 MACH_MSG_TYPE_MAKE_SEND);
642 lose("mach_port_insert_right failed with return_code %d\n", ret);
645 ret = thread_set_exception_ports(mach_thread_self(),
646 EXC_MASK_BAD_ACCESS | EXC_MASK_BAD_INSTRUCTION,
647 thread_exception_port,
651 lose("thread_set_exception_port failed with return_code %d\n", ret);
654 ret = mach_port_move_member(mach_task_self(),
655 thread_exception_port,
656 mach_exception_handler_port_set);
658 lose("mach_port_ failed with return_code %d\n", ret);
665 setup_mach_exceptions() {
666 setup_mach_exception_handling_thread();
667 mach_thread_init(THREAD_STRUCT_TO_EXCEPTION_PORT(all_threads));
674 setup_mach_exceptions();