3 #ifdef LISP_FEATURE_SB_THREAD
4 #include <architecture/i386/table.h>
5 #include <i386/user_ldt.h>
6 #include <mach/mach_init.h>
12 #include "interrupt.h"
13 #include "x86-darwin-os.h"
14 #include "genesis/fdefn.h"
16 #include <mach/mach.h>
17 #include <mach/mach_error.h>
18 #include <mach/mach_types.h>
19 #include <mach/sync_policy.h>
20 #include <mach/machine/thread_state.h>
21 #include <mach/machine/thread_status.h>
22 #include <sys/_types.h>
23 #include <sys/ucontext.h>
28 #ifdef LISP_FEATURE_SB_THREAD
30 pthread_mutex_t modify_ldt_lock = PTHREAD_MUTEX_INITIALIZER;
32 void set_data_desc_size(data_desc_t* desc, unsigned long size)
34 desc->limit00 = (size - 1) & 0xffff;
35 desc->limit16 = ((size - 1) >> 16) &0xf;
38 void set_data_desc_addr(data_desc_t* desc, void* addr)
40 desc->base00 = (unsigned int)addr & 0xffff;
41 desc->base16 = ((unsigned int)addr & 0xff0000) >> 16;
42 desc->base24 = ((unsigned int)addr & 0xff000000) >> 24;
47 #ifdef LISP_FEATURE_MACH_EXCEPTION_HANDLER
48 kern_return_t mach_thread_init(mach_port_t thread_exception_port);
51 int arch_os_thread_init(struct thread *thread) {
52 #ifdef LISP_FEATURE_SB_THREAD
56 data_desc_t ldt_entry = { 0, 0, 0, DESC_DATA_WRITE,
57 3, 1, 0, DESC_DATA_32B, DESC_GRAN_BYTE, 0 };
59 set_data_desc_addr(&ldt_entry, thread);
60 set_data_desc_size(&ldt_entry, dynamic_values_bytes);
62 thread_mutex_lock(&modify_ldt_lock);
63 n = i386_set_ldt(LDT_AUTO_ALLOC, (union ldt_entry*) &ldt_entry, 1);
66 perror("i386_set_ldt");
67 lose("unexpected i386_set_ldt(..) failure\n");
69 thread_mutex_unlock(&modify_ldt_lock);
71 FSHOW_SIGNAL((stderr, "/ TLS: Allocated LDT %x\n", n));
76 __asm__ __volatile__ ("mov %0, %%fs" : : "r"(sel));
79 pthread_setspecific(specials,thread);
81 #ifdef LISP_FEATURE_MACH_EXCEPTION_HANDLER
82 mach_thread_init(THREAD_STRUCT_TO_EXCEPTION_PORT(thread));
85 #ifdef LISP_FEATURE_C_STACK_IS_CONTROL_STACK
88 /* Signal handlers are run on the control stack, so if it is exhausted
89 * we had better use an alternate stack for whatever signal tells us
90 * we've exhausted it */
91 sigstack.ss_sp=((void *) thread)+dynamic_values_bytes;
93 sigstack.ss_size = 32*SIGSTKSZ;
94 sigaltstack(&sigstack,0);
96 return 1; /* success */
99 int arch_os_thread_cleanup(struct thread *thread) {
100 #if defined(LISP_FEATURE_SB_THREAD)
101 int n = thread->tls_cookie;
103 /* Set the %%fs register back to 0 and free the the ldt
104 * by setting it to NULL.
106 FSHOW_SIGNAL((stderr, "/ TLS: Freeing LDT %x\n", n));
108 __asm__ __volatile__ ("mov %0, %%fs" : : "r"(0));
109 thread_mutex_lock(&modify_ldt_lock);
110 i386_set_ldt(n, NULL, 1);
111 thread_mutex_unlock(&modify_ldt_lock);
113 return 1; /* success */
116 #ifdef LISP_FEATURE_MACH_EXCEPTION_HANDLER
118 void sigill_handler(int signal, siginfo_t *siginfo, void *void_context);
119 void sigtrap_handler(int signal, siginfo_t *siginfo, void *void_context);
120 void memory_fault_handler(int signal, siginfo_t *siginfo, void *void_context);
122 /* exc_server handles mach exception messages from the kernel and
123 * calls catch exception raise. We use the system-provided
124 * mach_msg_server, which, I assume, calls exc_server in a loop.
127 extern boolean_t exc_server();
129 /* This executes in the faulting thread as part of the signal
130 * emulation. It is passed a context with the uc_mcontext field
131 * pointing to a valid block of memory. */
132 void build_fake_signal_context(struct ucontext *context,
133 x86_thread_state32_t *thread_state,
134 x86_float_state32_t *float_state) {
135 pthread_sigmask(0, NULL, &context->uc_sigmask);
136 context->uc_mcontext->ss = *thread_state;
137 context->uc_mcontext->fs = *float_state;
140 /* This executes in the faulting thread as part of the signal
141 * emulation. It is effectively the inverse operation from above. */
142 void update_thread_state_from_context(x86_thread_state32_t *thread_state,
143 x86_float_state32_t *float_state,
144 struct ucontext *context) {
145 *thread_state = context->uc_mcontext->ss;
146 *float_state = context->uc_mcontext->fs;
147 pthread_sigmask(SIG_SETMASK, &context->uc_sigmask, NULL);
150 /* Modify a context to push new data on its stack. */
151 void push_context(u32 data, x86_thread_state32_t *context)
155 stack_pointer = (u32*) context->esp;
156 *(--stack_pointer) = data;
157 context->esp = (unsigned int) stack_pointer;
160 void align_context_stack(x86_thread_state32_t *context)
162 /* 16byte align the stack (provided that the stack is, as it
163 * should be, 4byte aligned. */
164 while (context->esp & 15) push_context(0, context);
167 /* Stack allocation starts with a context that has a mod-4 ESP value
168 * and needs to leave a context with a mod-16 ESP that will restore
169 * the old ESP value and other register state when activated. The
170 * first part of this is the recovery trampoline, which loads ESP from
171 * EBP, pops EBP, and returns. */
172 asm("_stack_allocation_recover: movl %ebp, %esp; popl %ebp; ret;");
174 void open_stack_allocation(x86_thread_state32_t *context)
176 void stack_allocation_recover(void);
178 push_context(context->eip, context);
179 push_context(context->ebp, context);
180 context->ebp = context->esp;
181 context->eip = (unsigned int) stack_allocation_recover;
183 align_context_stack(context);
186 /* Stack allocation of data starts with a context with a mod-16 ESP
187 * value and reserves some space on it by manipulating the ESP
189 void *stack_allocate(x86_thread_state32_t *context, size_t size)
191 /* round up size to 16byte multiple */
192 size = (size + 15) & -16;
194 context->esp = ((u32)context->esp) - size;
196 return (void *)context->esp;
199 /* Arranging to invoke a C function is tricky, as we have to assume
200 * cdecl calling conventions (caller removes args) and x86/darwin
201 * alignment requirements. The simplest way to arrange this,
202 * actually, is to open a new stack allocation.
203 * WARNING!!! THIS DOES NOT PRESERVE REGISTERS! */
204 void call_c_function_in_context(x86_thread_state32_t *context,
213 /* Set up to restore stack on exit. */
214 open_stack_allocation(context);
216 /* Have to keep stack 16byte aligned on x86/darwin. */
217 for (i = (3 & -nargs); i; i--) {
218 push_context(0, context);
221 context->esp = ((u32)context->esp) - nargs * 4;
222 stack_pointer = (u32 *)context->esp;
225 for (i = 0; i < nargs; i++) {
226 //push_context(va_arg(ap, u32), context);
227 stack_pointer[i] = va_arg(ap, u32);
231 push_context(context->eip, context);
232 context->eip = (unsigned int) function;
235 void signal_emulation_wrapper(x86_thread_state32_t *thread_state,
236 x86_float_state32_t *float_state,
239 void (*handler)(int, siginfo_t *, void *))
242 /* CLH: FIXME **NOTE: HACK ALERT!** Ideally, we would allocate
243 * context and regs on the stack as local variables, but this
244 * causes problems for the lisp debugger. When it walks the stack
245 * for a back trace, it sees the 1) address of the local variable
246 * on the stack and thinks that is a frame pointer to a lisp
247 * frame, and, 2) the address of the sap that we alloc'ed in
248 * dynamic space and thinks that is a return address, so it,
249 * heuristicly (and wrongly), chooses that this should be
250 * interpreted as a lisp frame instead of as a C frame.
251 * We can work around this in this case by os_validating the
252 * context (and regs just for symmetry).
255 struct ucontext *context;
256 struct mcontext *regs;
259 context = (struct ucontext*) os_validate(0, sizeof(struct ucontext));
260 regs = (struct mcontext*) os_validate(0, sizeof(struct mcontext));
261 context->uc_mcontext = regs;
263 /* when BSD signals are fired, they mask they signals in sa_mask
264 which always seem to be the blockable_sigset, for us, so we
266 1) save the current sigmask
267 2) block blockable signals
268 3) call the signal handler
269 4) restore the sigmask */
271 pthread_sigmask(0, NULL, &sigmask);
272 block_blockable_signals();
274 build_fake_signal_context(context, thread_state, float_state);
276 handler(signal, siginfo, context);
278 update_thread_state_from_context(thread_state, float_state, context);
280 pthread_sigmask(SIG_SETMASK, &sigmask, NULL);
282 os_invalidate((os_vm_address_t)context, sizeof(struct ucontext));
283 os_invalidate((os_vm_address_t)regs, sizeof(struct mcontext));
285 /* Trap to restore the signal context. */
286 asm volatile ("movl %0, %%eax; .long 0xffff0b0f": : "r" (thread_state));
289 #if defined DUMP_CONTEXT
290 void dump_context(x86_thread_state32_t *context)
295 printf("eax: %08lx ecx: %08lx edx: %08lx ebx: %08lx\n",
296 context->eax, context->ecx, context->edx, context->ebx);
297 printf("esp: %08lx ebp: %08lx esi: %08lx edi: %08lx\n",
298 context->esp, context->ebp, context->esi, context->edi);
299 printf("eip: %08lx eflags: %08lx\n",
300 context->eip, context->eflags);
301 printf("cs: %04hx ds: %04hx es: %04hx "
302 "ss: %04hx fs: %04hx gs: %04hx\n",
303 context->cs, context->ds, context->es,
304 context->ss, context->fs, context->gs);
306 stack_pointer = (u32 *)context->esp;
307 for (i = 0; i < 48; i+=4) {
308 printf("%08x: %08x %08x %08x %08x\n",
309 context->esp + (i * 4),
319 control_stack_exhausted_handler(int signal, siginfo_t *siginfo, void *void_context) {
320 os_context_t *context = arch_os_get_context(&void_context);
322 arrange_return_to_lisp_function
323 (context, SymbolFunction(CONTROL_STACK_EXHAUSTED_ERROR));
327 undefined_alien_handler(int signal, siginfo_t *siginfo, void *void_context) {
328 os_context_t *context = arch_os_get_context(&void_context);
330 arrange_return_to_lisp_function
331 (context, SymbolFunction(UNDEFINED_ALIEN_VARIABLE_ERROR));
335 catch_exception_raise(mach_port_t exception_port,
338 exception_type_t exception,
339 exception_data_t code_vector,
340 mach_msg_type_number_t code_count)
346 x86_thread_state32_t thread_state;
347 mach_msg_type_number_t thread_state_count = x86_THREAD_STATE32_COUNT;
349 x86_float_state32_t float_state;
350 mach_msg_type_number_t float_state_count = x86_FLOAT_STATE32_COUNT;
352 x86_exception_state32_t exception_state;
353 mach_msg_type_number_t exception_state_count = x86_EXCEPTION_STATE32_COUNT;
355 x86_thread_state32_t backup_thread_state;
356 x86_thread_state32_t *target_thread_state;
357 x86_float_state32_t *target_float_state;
359 os_vm_address_t addr;
361 struct thread *th = (struct thread*) exception_port;
363 FSHOW((stderr,"/entering catch_exception_raise with exception: %d\n", exception));
369 ret = thread_get_state(thread,
371 (thread_state_t)&thread_state,
372 &thread_state_count);
373 ret = thread_get_state(thread,
375 (thread_state_t)&float_state,
377 ret = thread_get_state(thread,
378 x86_EXCEPTION_STATE32,
379 (thread_state_t)&exception_state,
380 &exception_state_count);
381 addr = (void*)exception_state.faultvaddr;
384 /* note the os_context hackery here. When the signal handler returns,
385 * it won't go back to what it was doing ... */
386 if(addr >= CONTROL_STACK_GUARD_PAGE(th) &&
387 addr < CONTROL_STACK_GUARD_PAGE(th) + os_vm_page_size) {
388 /* We hit the end of the control stack: disable guard page
389 * protection so the error handler has some headroom, protect the
390 * previous page so that we can catch returns from the guard page
392 protect_control_stack_guard_page_thread(0, th);
393 protect_control_stack_return_guard_page_thread(1, th);
395 backup_thread_state = thread_state;
396 open_stack_allocation(&thread_state);
398 /* Save thread state */
399 target_thread_state =
400 stack_allocate(&thread_state, sizeof(*target_thread_state));
401 (*target_thread_state) = backup_thread_state;
403 /* Save float state */
405 stack_allocate(&thread_state, sizeof(*target_float_state));
406 (*target_float_state) = float_state;
409 siginfo = stack_allocate(&thread_state, sizeof(*siginfo));
410 /* what do we need to put in our fake siginfo? It looks like
411 * the x86 code only uses si_signo and si_adrr. */
412 siginfo->si_signo = signal;
413 siginfo->si_addr = (void*)exception_state.faultvaddr;
415 call_c_function_in_context(&thread_state,
416 signal_emulation_wrapper,
422 control_stack_exhausted_handler);
424 else if(addr >= CONTROL_STACK_RETURN_GUARD_PAGE(th) &&
425 addr < CONTROL_STACK_RETURN_GUARD_PAGE(th) + os_vm_page_size) {
426 /* We're returning from the guard page: reprotect it, and
427 * unprotect this one. This works even if we somehow missed
428 * the return-guard-page, and hit it on our way to new
429 * exhaustion instead. */
430 protect_control_stack_guard_page_thread(1, th);
431 protect_control_stack_return_guard_page_thread(0, th);
434 else if (addr >= undefined_alien_address &&
435 addr < undefined_alien_address + os_vm_page_size) {
436 backup_thread_state = thread_state;
437 open_stack_allocation(&thread_state);
439 /* Save thread state */
440 target_thread_state =
441 stack_allocate(&thread_state, sizeof(*target_thread_state));
442 (*target_thread_state) = backup_thread_state;
445 stack_allocate(&thread_state, sizeof(*target_float_state));
446 (*target_float_state) = float_state;
449 siginfo = stack_allocate(&thread_state, sizeof(*siginfo));
450 /* what do we need to put in our fake siginfo? It looks like
451 * the x86 code only uses si_signo and si_adrr. */
452 siginfo->si_signo = signal;
453 siginfo->si_addr = (void*)exception_state.faultvaddr;
455 call_c_function_in_context(&thread_state,
456 signal_emulation_wrapper,
462 undefined_alien_handler);
465 backup_thread_state = thread_state;
466 open_stack_allocation(&thread_state);
468 /* Save thread state */
469 target_thread_state =
470 stack_allocate(&thread_state, sizeof(*target_thread_state));
471 (*target_thread_state) = backup_thread_state;
474 stack_allocate(&thread_state, sizeof(*target_float_state));
475 (*target_float_state) = float_state;
478 siginfo = stack_allocate(&thread_state, sizeof(*siginfo));
479 /* what do we need to put in our fake siginfo? It looks like
480 * the x86 code only uses si_signo and si_adrr. */
481 siginfo->si_signo = signal;
482 siginfo->si_addr = (void*)exception_state.faultvaddr;
484 call_c_function_in_context(&thread_state,
485 signal_emulation_wrapper,
491 memory_fault_handler);
493 ret = thread_set_state(thread,
495 (thread_state_t)&thread_state,
498 ret = thread_set_state(thread,
500 (thread_state_t)&float_state,
504 case EXC_BAD_INSTRUCTION:
506 ret = thread_get_state(thread,
508 (thread_state_t)&thread_state,
509 &thread_state_count);
510 ret = thread_get_state(thread,
512 (thread_state_t)&float_state,
514 ret = thread_get_state(thread,
515 x86_EXCEPTION_STATE32,
516 (thread_state_t)&exception_state,
517 &exception_state_count);
518 if (0xffff0b0f == *((u32 *)thread_state.eip)) {
519 /* fake sigreturn. */
521 /* When we get here, thread_state.eax is a pointer to a
522 * thread_state to restore. */
523 /* thread_state = *((thread_state_t *)thread_state.eax); */
525 ret = thread_set_state(thread,
527 (thread_state_t) thread_state.eax,
532 backup_thread_state = thread_state;
533 open_stack_allocation(&thread_state);
535 /* Save thread state */
536 target_thread_state =
537 stack_allocate(&thread_state, sizeof(*target_thread_state));
538 (*target_thread_state) = backup_thread_state;
541 stack_allocate(&thread_state, sizeof(*target_float_state));
542 (*target_float_state) = float_state;
545 siginfo = stack_allocate(&thread_state, sizeof(*siginfo));
546 /* what do we need to put in our fake siginfo? It looks like
547 * the x86 code only uses si_signo and si_adrr. */
548 if (*((unsigned short *)target_thread_state->eip) == 0x0b0f) {
550 siginfo->si_signo = signal;
551 siginfo->si_addr = (void*)exception_state.faultvaddr;
552 target_thread_state->eip += 2;
553 call_c_function_in_context(&thread_state,
554 signal_emulation_wrapper,
563 siginfo->si_signo = signal;
564 siginfo->si_addr = (void*)exception_state.faultvaddr;
566 call_c_function_in_context(&thread_state,
567 signal_emulation_wrapper,
575 ret = thread_set_state(thread,
577 (thread_state_t)&thread_state,
579 ret = thread_set_state(thread,
581 (thread_state_t)&float_state,
587 return KERN_INVALID_RIGHT;
592 mach_exception_handler(void *port)
594 mach_msg_server(exc_server, 2048, (mach_port_t) port, 0);
595 /* mach_msg_server should never return, but it should dispatch mach
596 * exceptions to our catch_exception_raise function
603 #ifdef LISP_FEATURE_MACH_EXCEPTION_HANDLER
605 /* Sets up the thread that will listen for mach exceptions. note that
606 the exception handlers will be run on this thread. This is
607 different from the BSD-style signal handling situation in which the
608 signal handlers run in the relevant thread directly. */
610 mach_port_t mach_exception_handler_port_set = MACH_PORT_NULL;
613 setup_mach_exception_handling_thread()
616 pthread_t mach_exception_handling_thread = NULL;
619 /* allocate a mach_port for this process */
620 ret = mach_port_allocate(mach_task_self(),
621 MACH_PORT_RIGHT_PORT_SET,
622 &mach_exception_handler_port_set);
624 /* create the thread that will receive the mach exceptions */
626 FSHOW((stderr, "Creating mach_exception_handler thread!\n"));
628 pthread_attr_init(&attr);
629 pthread_create(&mach_exception_handling_thread,
631 mach_exception_handler,
632 (void*) mach_exception_handler_port_set);
633 pthread_attr_destroy(&attr);
635 return mach_exception_handling_thread;
638 /* tell the kernel that we want EXC_BAD_ACCESS exceptions sent to the
639 exception port (which is being listened to do by the mach
640 exception handling thread). */
642 mach_thread_init(mach_port_t thread_exception_port)
645 /* allocate a named port for the thread */
647 FSHOW((stderr, "Allocating mach port %x\n", thread_exception_port));
649 ret = mach_port_allocate_name(mach_task_self(),
650 MACH_PORT_RIGHT_RECEIVE,
651 thread_exception_port);
653 lose("mach_port_allocate_name failed with return_code %d\n", ret);
656 /* establish the right for the thread_exception_port to send messages */
657 ret = mach_port_insert_right(mach_task_self(),
658 thread_exception_port,
659 thread_exception_port,
660 MACH_MSG_TYPE_MAKE_SEND);
662 lose("mach_port_insert_right failed with return_code %d\n", ret);
665 ret = thread_set_exception_ports(mach_thread_self(),
666 EXC_MASK_BAD_ACCESS | EXC_MASK_BAD_INSTRUCTION,
667 thread_exception_port,
671 lose("thread_set_exception_port failed with return_code %d\n", ret);
674 ret = mach_port_move_member(mach_task_self(),
675 thread_exception_port,
676 mach_exception_handler_port_set);
678 lose("mach_port_ failed with return_code %d\n", ret);
685 setup_mach_exceptions() {
686 setup_mach_exception_handling_thread();
687 mach_thread_init(THREAD_STRUCT_TO_EXCEPTION_PORT(all_threads));
694 setup_mach_exceptions();