1.0.26.8: QSHOW changes, bug reporting guidelines
[sbcl.git] / src / runtime / x86-64-darwin-os.c
1 #ifdef LISP_FEATURE_SB_THREAD
2 #include <architecture/i386/table.h>
3 #include <i386/user_ldt.h>
4 #include <mach/mach_init.h>
5 #endif
6
7 #include "thread.h"
8 #include "validate.h"
9 #include "runtime.h"
10 #include "interrupt.h"
11 #include "x86-64-darwin-os.h"
12 #include "genesis/fdefn.h"
13
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>
22 #include <pthread.h>
23 #include <assert.h>
24 #include <stdlib.h>
25 #include <stdio.h>
26
27 #if __DARWIN_UNIX03
28 #include <sys/_structs.h>
29 #endif
30
31 #if __DARWIN_UNIX03
32
33 typedef struct __darwin_ucontext darwin_ucontext;
34 typedef struct __darwin_mcontext64 darwin_mcontext;
35
36 #define rip __rip
37 #define rsp __rsp
38 #define rbp __rbp
39 #define rax __rax
40 #define rbx __rbx
41 #define rcx __rcx
42 #define rdx __rdx
43 #define rsi __rsi
44 #define rdi __rdi
45 #define r8 __r8
46 #define r9 __r9
47 #define faultvaddr __faultvaddr
48 #define ss __ss
49 #define es __es
50 #define fs __fs
51
52 #else
53
54 typedef struct ucontext darwin_ucontext;
55 typedef struct mcontext darwin_mcontext;
56
57 #endif
58
59 #ifdef LISP_FEATURE_SB_THREAD
60 pthread_mutex_t mach_exception_lock = PTHREAD_MUTEX_INITIALIZER;
61 #endif
62
63 #ifdef LISP_FEATURE_MACH_EXCEPTION_HANDLER
64
65 kern_return_t mach_thread_init(mach_port_t thread_exception_port);
66
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);
71
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.
75  *
76  */
77 extern boolean_t exc_server();
78
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;
88 }
89
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);
98 }
99
100 /* Modify a context to push new data on its stack. */
101 void push_context(u64 data, x86_thread_state64_t *context)
102 {
103     u64 *stack_pointer;
104
105     stack_pointer = (u64*) context->rsp;
106     *(--stack_pointer) = data;
107     context->rsp = (u64) stack_pointer;
108 }
109
110 void align_context_stack(x86_thread_state64_t *context)
111 {
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);
115 }
116
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;");
124
125 void open_stack_allocation(x86_thread_state64_t *context)
126 {
127     void stack_allocation_recover(void);
128
129     push_context(context->rip, context);
130     push_context(context->rbp, context);
131
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);
138
139     context->rbp = context->rsp;
140     context->rip = (u64) stack_allocation_recover;
141
142     align_context_stack(context);
143 }
144
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
147  * register. */
148 void *stack_allocate(x86_thread_state64_t *context, size_t size)
149 {
150     /* round up size to 16byte multiple */
151     size = (size + 15) & -16;
152
153     context->rsp = ((u64)context->rsp) - size;
154
155     return (void *)context->rsp;
156 }
157
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,
164                                 void *function,
165                                 int nargs,
166                                 ...)
167 {
168     va_list ap;
169     int i;
170     u64 *stack_pointer;
171
172     /* Set up to restore stack on exit. */
173     open_stack_allocation(context);
174
175     /* Have to keep stack 16byte aligned on x86/darwin. */
176     for (i = (1 & -nargs); i; i--) {
177         push_context(0, context);
178     }
179
180     context->rsp = ((u64)context->rsp) - nargs * 8;
181     stack_pointer = (u64 *)context->rsp;
182
183     va_start(ap, nargs);
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);
192     }
193     va_end(ap);
194
195     push_context(context->rip, context);
196     context->rip = (u64) function;
197 }
198
199 void signal_emulation_wrapper(x86_thread_state64_t *thread_state,
200                               x86_float_state64_t *float_state,
201                               int signal,
202                               siginfo_t *siginfo,
203                               void (*handler)(int, siginfo_t *, void *))
204 {
205
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).
217      */
218
219     darwin_ucontext  *context;
220     darwin_mcontext *regs;
221
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;
225
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
228        need to:
229        1) save the current sigmask
230        2) block blockable signals
231        3) call the signal handler
232        4) restore the sigmask */
233
234     build_fake_signal_context(context, thread_state, float_state);
235
236     block_blockable_signals();
237
238     handler(signal, siginfo, context);
239
240     update_thread_state_from_context(thread_state, float_state, context);
241
242     os_invalidate((os_vm_address_t)context, sizeof(darwin_ucontext));
243     os_invalidate((os_vm_address_t)regs, sizeof(darwin_mcontext));
244
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));
248 }
249
250 #if defined DUMP_CONTEXT
251 void dump_context(x86_thread_state64_t *context)
252 {
253     int i;
254     u64 *stack_pointer;
255
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);
266
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),
271                stack_pointer[i],
272                stack_pointer[i+1],
273                stack_pointer[i+2],
274                stack_pointer[i+3]);
275     }
276 }
277 #endif
278
279 void
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));
285 }
286
287 void
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));
291 }
292
293 kern_return_t
294 catch_exception_raise(mach_port_t exception_port,
295                       mach_port_t thread,
296                       mach_port_t task,
297                       exception_type_t exception,
298                       exception_data_t code_vector,
299                       mach_msg_type_number_t code_count)
300 {
301     kern_return_t ret;
302     int signal;
303     siginfo_t* siginfo;
304
305 #ifdef LISP_FEATURE_SB_THREAD
306     thread_mutex_lock(&mach_exception_lock);
307 #endif
308
309     x86_thread_state64_t thread_state;
310     mach_msg_type_number_t thread_state_count = x86_THREAD_STATE64_COUNT;
311
312     x86_float_state64_t float_state;
313     mach_msg_type_number_t float_state_count = x86_FLOAT_STATE64_COUNT;
314
315     x86_exception_state64_t exception_state;
316     mach_msg_type_number_t exception_state_count = x86_EXCEPTION_STATE64_COUNT;
317
318     x86_thread_state64_t backup_thread_state;
319     x86_thread_state64_t *target_thread_state;
320     x86_float_state64_t *target_float_state;
321
322     os_vm_address_t addr;
323
324     struct thread *th = (struct thread*) exception_port;
325
326     FSHOW((stderr,"/entering catch_exception_raise with exception: %d\n", exception));
327
328     switch (exception) {
329
330     case EXC_BAD_ACCESS:
331         signal = SIGBUS;
332         ret = thread_get_state(thread,
333                                x86_THREAD_STATE64,
334                                (thread_state_t)&thread_state,
335                                &thread_state_count);
336         ret = thread_get_state(thread,
337                                x86_FLOAT_STATE64,
338                                (thread_state_t)&float_state,
339                                &float_state_count);
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;
345
346
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
354              * and restore it. */
355             protect_control_stack_guard_page(0, th);
356             protect_control_stack_return_guard_page(1, th);
357
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.
362              */
363             stack_allocate(&thread_state, 256);
364
365             /* Save thread state */
366             target_thread_state =
367                 stack_allocate(&thread_state, sizeof(*target_thread_state));
368             (*target_thread_state) = backup_thread_state;
369
370             /* Save float state */
371             target_float_state =
372                 stack_allocate(&thread_state, sizeof(*target_float_state));
373             (*target_float_state) = float_state;
374
375             /* Set up siginfo */
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;
381
382             call_c_function_in_context(&thread_state,
383                                        signal_emulation_wrapper,
384                                        5,
385                                        target_thread_state,
386                                        target_float_state,
387                                        signal,
388                                        siginfo,
389                                        control_stack_exhausted_handler);
390         }
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);
399         }
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);
405
406             /* Save thread state */
407             target_thread_state =
408                 stack_allocate(&thread_state, sizeof(*target_thread_state));
409             (*target_thread_state) = backup_thread_state;
410
411             target_float_state =
412                 stack_allocate(&thread_state, sizeof(*target_float_state));
413             (*target_float_state) = float_state;
414
415             /* Set up siginfo */
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;
421
422             call_c_function_in_context(&thread_state,
423                                        signal_emulation_wrapper,
424                                        5,
425                                        target_thread_state,
426                                        target_float_state,
427                                        signal,
428                                        siginfo,
429                                        undefined_alien_handler);
430         } else {
431
432             backup_thread_state = thread_state;
433             open_stack_allocation(&thread_state);
434             stack_allocate(&thread_state, 256);
435
436             /* Save thread state */
437             target_thread_state =
438                 stack_allocate(&thread_state, sizeof(*target_thread_state));
439             (*target_thread_state) = backup_thread_state;
440
441             target_float_state =
442                 stack_allocate(&thread_state, sizeof(*target_float_state));
443             (*target_float_state) = float_state;
444
445             /* Set up siginfo */
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;
451
452             call_c_function_in_context(&thread_state,
453                                        signal_emulation_wrapper,
454                                        5,
455                                        target_thread_state,
456                                        target_float_state,
457                                        signal,
458                                        siginfo,
459                                        memory_fault_handler);
460         }
461         ret = thread_set_state(thread,
462                                x86_THREAD_STATE64,
463                                (thread_state_t)&thread_state,
464                                thread_state_count);
465
466         ret = thread_set_state(thread,
467                                x86_FLOAT_STATE64,
468                                (thread_state_t)&float_state,
469                                float_state_count);
470 #ifdef LISP_FEATURE_SB_THREAD
471         thread_mutex_unlock(&mach_exception_lock);
472 #endif
473         return KERN_SUCCESS;
474
475     case EXC_BAD_INSTRUCTION:
476
477         ret = thread_get_state(thread,
478                                x86_THREAD_STATE64,
479                                (thread_state_t)&thread_state,
480                                &thread_state_count);
481         ret = thread_get_state(thread,
482                                x86_FLOAT_STATE64,
483                                (thread_state_t)&float_state,
484                                &float_state_count);
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. */
491
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); */
495
496             ret = thread_set_state(thread,
497                                    x86_THREAD_STATE64,
498                                    (thread_state_t) thread_state.rax,
499                                    /* &thread_state, */
500                                    thread_state_count);
501
502             ret = thread_set_state(thread,
503                                    x86_FLOAT_STATE64,
504                                    (thread_state_t) thread_state.rbx,
505                                    /* &thread_state, */
506                                    float_state_count);
507         } else {
508
509             backup_thread_state = thread_state;
510             open_stack_allocation(&thread_state);
511             stack_allocate(&thread_state, 256);
512
513             /* Save thread state */
514             target_thread_state =
515                 stack_allocate(&thread_state, sizeof(*target_thread_state));
516             (*target_thread_state) = backup_thread_state;
517
518             target_float_state =
519                 stack_allocate(&thread_state, sizeof(*target_float_state));
520             (*target_float_state) = float_state;
521
522             /* Set up siginfo */
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) {
527                 signal = SIGTRAP;
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,
533                                            5,
534                                            target_thread_state,
535                                            target_float_state,
536                                            signal,
537                                            siginfo,
538                                            sigtrap_handler);
539             } else {
540                 signal = SIGILL;
541                 siginfo->si_signo = signal;
542                 siginfo->si_addr = (void*)exception_state.faultvaddr;
543
544                 call_c_function_in_context(&thread_state,
545                                            signal_emulation_wrapper,
546                                            5,
547                                            target_thread_state,
548                                            target_float_state,
549                                            signal,
550                                            siginfo,
551                                            sigill_handler);
552             }
553             ret = thread_set_state(thread,
554                                    x86_THREAD_STATE64,
555                                    (thread_state_t)&thread_state,
556                                    thread_state_count);
557             ret = thread_set_state(thread,
558                                    x86_FLOAT_STATE64,
559                                    (thread_state_t)&float_state,
560                                    float_state_count);
561         }
562 #ifdef LISP_FEATURE_SB_THREAD
563         thread_mutex_unlock(&mach_exception_lock);
564 #endif
565         return KERN_SUCCESS;
566
567     default:
568 #ifdef LISP_FEATURE_SB_THREAD
569         thread_mutex_unlock(&mach_exception_lock);
570 #endif
571         return KERN_INVALID_RIGHT;
572     }
573 }
574
575 void *
576 mach_exception_handler(void *port)
577 {
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
581    */
582   abort();
583 }
584
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. */
589
590 mach_port_t mach_exception_handler_port_set = MACH_PORT_NULL;
591
592 pthread_t
593 setup_mach_exception_handling_thread()
594 {
595     kern_return_t ret;
596     pthread_t mach_exception_handling_thread = NULL;
597     pthread_attr_t attr;
598
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);
603
604     /* create the thread that will receive the mach exceptions */
605
606     FSHOW((stderr, "Creating mach_exception_handler thread!\n"));
607
608     pthread_attr_init(&attr);
609     pthread_create(&mach_exception_handling_thread,
610                    &attr,
611                    mach_exception_handler,
612                    (void*) mach_exception_handler_port_set);
613     pthread_attr_destroy(&attr);
614
615     return mach_exception_handling_thread;
616 }
617
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). */
621 kern_return_t
622 mach_thread_init(mach_port_t thread_exception_port)
623 {
624     kern_return_t ret;
625     /* allocate a named port for the thread */
626
627     FSHOW((stderr, "Allocating mach port %x\n", thread_exception_port));
628
629     ret = mach_port_allocate_name(mach_task_self(),
630                                   MACH_PORT_RIGHT_RECEIVE,
631                                   thread_exception_port);
632     if (ret) {
633         lose("mach_port_allocate_name failed with return_code %d\n", ret);
634     }
635
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);
641     if (ret) {
642         lose("mach_port_insert_right failed with return_code %d\n", ret);
643     }
644
645     ret = thread_set_exception_ports(mach_thread_self(),
646                                      EXC_MASK_BAD_ACCESS | EXC_MASK_BAD_INSTRUCTION,
647                                      thread_exception_port,
648                                      EXCEPTION_DEFAULT,
649                                      THREAD_STATE_NONE);
650     if (ret) {
651         lose("thread_set_exception_port failed with return_code %d\n", ret);
652     }
653
654     ret = mach_port_move_member(mach_task_self(),
655                                 thread_exception_port,
656                                 mach_exception_handler_port_set);
657     if (ret) {
658         lose("mach_port_ failed with return_code %d\n", ret);
659     }
660
661     return ret;
662 }
663
664 void
665 setup_mach_exceptions() {
666     setup_mach_exception_handling_thread();
667     mach_thread_init(THREAD_STRUCT_TO_EXCEPTION_PORT(all_threads));
668 }
669
670 pid_t
671 mach_fork() {
672     pid_t pid = fork();
673     if (pid == 0) {
674         setup_mach_exceptions();
675         return pid;
676     } else {
677         return pid;
678     }
679 }
680
681 #endif