1.0.26.2: alloc_code_object facelift
[sbcl.git] / src / runtime / x86-64-darwin-os.c
1
2 #ifdef LISP_FEATURE_SB_THREAD
3 #include <architecture/i386/table.h>
4 #include <i386/user_ldt.h>
5 #include <mach/mach_init.h>
6 #endif
7
8 #include "thread.h"
9 #include "validate.h"
10 #include "runtime.h"
11 #include "interrupt.h"
12 #include "x86-64-darwin-os.h"
13 #include "genesis/fdefn.h"
14
15 #include <mach/mach.h>
16 #include <mach/mach_error.h>
17 #include <mach/mach_types.h>
18 #include <mach/sync_policy.h>
19 #include <mach/machine/thread_state.h>
20 #include <mach/machine/thread_status.h>
21 #include <sys/_types.h>
22 #include <sys/ucontext.h>
23 #include <pthread.h>
24 #include <assert.h>
25 #include <stdlib.h>
26 #include <stdio.h>
27
28 #if __DARWIN_UNIX03
29 #include <sys/_structs.h>
30 #endif
31
32 #if __DARWIN_UNIX03
33
34 typedef struct __darwin_ucontext darwin_ucontext;
35 typedef struct __darwin_mcontext64 darwin_mcontext;
36
37 #define rip __rip
38 #define rsp __rsp
39 #define rbp __rbp
40 #define rax __rax
41 #define rbx __rbx
42 #define rcx __rcx
43 #define rdx __rdx
44 #define rsi __rsi
45 #define rdi __rdi
46 #define r8 __r8
47 #define r9 __r9
48 #define faultvaddr __faultvaddr
49 #define ss __ss
50 #define es __es
51 #define fs __fs
52
53 #else
54
55 typedef struct ucontext darwin_ucontext;
56 typedef struct mcontext darwin_mcontext;
57
58 #endif
59
60 #ifdef LISP_FEATURE_SB_THREAD
61 pthread_mutex_t mach_exception_lock = PTHREAD_MUTEX_INITIALIZER;
62 #endif
63
64 #ifdef LISP_FEATURE_MACH_EXCEPTION_HANDLER
65
66 kern_return_t mach_thread_init(mach_port_t thread_exception_port);
67
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);
72
73 /* exc_server handles mach exception messages from the kernel and
74  * calls catch exception raise. We use the system-provided
75  * mach_msg_server, which, I assume, calls exc_server in a loop.
76  *
77  */
78 extern boolean_t exc_server();
79
80 /* This executes in the faulting thread as part of the signal
81  * emulation.  It is passed a context with the uc_mcontext field
82  * pointing to a valid block of memory. */
83 void build_fake_signal_context(darwin_ucontext *context,
84                                x86_thread_state64_t *thread_state,
85                                x86_float_state64_t *float_state) {
86     pthread_sigmask(0, NULL, &context->uc_sigmask);
87     context->uc_mcontext->ss = *thread_state;
88     context->uc_mcontext->fs = *float_state;
89 }
90
91 /* This executes in the faulting thread as part of the signal
92  * emulation.  It is effectively the inverse operation from above. */
93 void update_thread_state_from_context(x86_thread_state64_t *thread_state,
94                                       x86_float_state64_t *float_state,
95                                       darwin_ucontext  *context) {
96     *thread_state = context->uc_mcontext->ss;
97     *float_state = context->uc_mcontext->fs;
98     pthread_sigmask(SIG_SETMASK, &context->uc_sigmask, NULL);
99 }
100
101 /* Modify a context to push new data on its stack. */
102 void push_context(u64 data, x86_thread_state64_t *context)
103 {
104     u64 *stack_pointer;
105
106     stack_pointer = (u64*) context->rsp;
107     *(--stack_pointer) = data;
108     context->rsp = (u64) stack_pointer;
109 }
110
111 void align_context_stack(x86_thread_state64_t *context)
112 {
113     /* 16byte align the stack (provided that the stack is, as it
114      * should be, 8byte aligned. */
115     while (context->rsp & 15) push_context(0, context);
116 }
117
118 /* Stack allocation starts with a context that has a mod-4 ESP value
119  * and needs to leave a context with a mod-16 ESP that will restore
120  * the old ESP value and other register state when activated.  The
121  * first part of this is the recovery trampoline, which loads ESP from
122  * EBP, pops EBP, and returns. */
123 asm(".globl _stack_allocation_recover; .align 4; _stack_allocation_recover: mov %rbp, %rsp; pop %rsi; pop %rdi; pop \
124 %rdx; pop %rcx; pop %r8; pop %r9; pop %rbp; ret;");
125
126 void open_stack_allocation(x86_thread_state64_t *context)
127 {
128     void stack_allocation_recover(void);
129
130     push_context(context->rip, context);
131     push_context(context->rbp, context);
132
133     push_context(context->r9, context);
134     push_context(context->r8, context);
135     push_context(context->rcx, context);
136     push_context(context->rdx, context);
137     push_context(context->rsi, context);
138     push_context(context->rdi, context);
139
140     context->rbp = context->rsp;
141     context->rip = (u64) stack_allocation_recover;
142
143     align_context_stack(context);
144 }
145
146 /* Stack allocation of data starts with a context with a mod-16 ESP
147  * value and reserves some space on it by manipulating the ESP
148  * register. */
149 void *stack_allocate(x86_thread_state64_t *context, size_t size)
150 {
151     /* round up size to 16byte multiple */
152     size = (size + 15) & -16;
153
154     context->rsp = ((u64)context->rsp) - size;
155
156     return (void *)context->rsp;
157 }
158
159 /* Arranging to invoke a C function is tricky, as we have to assume
160  * cdecl calling conventions (caller removes args) and x86/darwin
161  * alignment requirements.  The simplest way to arrange this,
162  * actually, is to open a new stack allocation.
163  * WARNING!!! THIS DOES NOT PRESERVE REGISTERS! */
164 void call_c_function_in_context(x86_thread_state64_t *context,
165                                 void *function,
166                                 int nargs,
167                                 ...)
168 {
169     va_list ap;
170     int i;
171     u64 *stack_pointer;
172
173     /* Set up to restore stack on exit. */
174     open_stack_allocation(context);
175
176     /* Have to keep stack 16byte aligned on x86/darwin. */
177     for (i = (1 & -nargs); i; i--) {
178         push_context(0, context);
179     }
180
181     context->rsp = ((u64)context->rsp) - nargs * 8;
182     stack_pointer = (u64 *)context->rsp;
183
184     va_start(ap, nargs);
185     if (nargs > 0) context->rdi = va_arg(ap, u64);
186     if (nargs > 1) context->rsi = va_arg(ap, u64);
187     if (nargs > 2) context->rdx = va_arg(ap, u64);
188     if (nargs > 3) context->rcx = va_arg(ap, u64);
189     if (nargs > 4) context->r8 = va_arg(ap, u64);
190     if (nargs > 5) context->r9 = va_arg(ap, u64);
191     for (i = 6; i < nargs; i++) {
192         stack_pointer[i] = va_arg(ap, u64);
193     }
194     va_end(ap);
195
196     push_context(context->rip, context);
197     context->rip = (u64) function;
198 }
199
200 void signal_emulation_wrapper(x86_thread_state64_t *thread_state,
201                               x86_float_state64_t *float_state,
202                               int signal,
203                               siginfo_t *siginfo,
204                               void (*handler)(int, siginfo_t *, void *))
205 {
206
207     /* CLH: FIXME **NOTE: HACK ALERT!** Ideally, we would allocate
208      * context and regs on the stack as local variables, but this
209      * causes problems for the lisp debugger. When it walks the stack
210      * for a back trace, it sees the 1) address of the local variable
211      * on the stack and thinks that is a frame pointer to a lisp
212      * frame, and, 2) the address of the sap that we alloc'ed in
213      * dynamic space and thinks that is a return address, so it,
214      * heuristicly (and wrongly), chooses that this should be
215      * interpreted as a lisp frame instead of as a C frame.
216      * We can work around this in this case by os_validating the
217      * context (and regs just for symmetry).
218      */
219
220     darwin_ucontext  *context;
221     darwin_mcontext *regs;
222
223     context = (darwin_ucontext *) os_validate(0, sizeof(darwin_ucontext));
224     regs = (darwin_mcontext*) os_validate(0, sizeof(darwin_mcontext));
225     context->uc_mcontext = regs;
226
227     /* when BSD signals are fired, they mask they signals in sa_mask
228        which always seem to be the blockable_sigset, for us, so we
229        need to:
230        1) save the current sigmask
231        2) block blockable signals
232        3) call the signal handler
233        4) restore the sigmask */
234
235     build_fake_signal_context(context, thread_state, float_state);
236
237     block_blockable_signals();
238
239     handler(signal, siginfo, context);
240
241     update_thread_state_from_context(thread_state, float_state, context);
242
243     os_invalidate((os_vm_address_t)context, sizeof(darwin_ucontext));
244     os_invalidate((os_vm_address_t)regs, sizeof(darwin_mcontext));
245
246     /* Trap to restore the signal context. */
247     asm volatile ("mov %0, %%rax; mov %1, %%rbx; .quad 0xffffffffffff0b0f"
248                   : : "r" (thread_state), "r" (float_state));
249 }
250
251 #if defined DUMP_CONTEXT
252 void dump_context(x86_thread_state64_t *context)
253 {
254     int i;
255     u64 *stack_pointer;
256
257     printf("rax: %08lx  rcx: %08lx  rdx: %08lx  rbx: %08lx\n",
258            context->rax, context->rcx, context->rdx, context->rbx);
259     printf("rsp: %08lx  rbp: %08lx  rsi: %08lx  rdi: %08lx\n",
260            context->rsp, context->rbp, context->rsi, context->rdi);
261     printf("rip: %08lx  eflags: %08lx\n",
262            context->rip, context->rflags);
263     printf("cs: %04hx  ds: %04hx  es: %04hx  "
264            "ss: %04hx  fs: %04hx  gs: %04hx\n",
265            context->cs, context->ds, context->rs,
266            context->ss, context->fs, context->gs);
267
268     stack_pointer = (u64 *)context->rsp;
269     for (i = 0; i < 48; i+=4) {
270         printf("%08x:  %08x %08x %08x %08x\n",
271                context->rsp + (i * 4),
272                stack_pointer[i],
273                stack_pointer[i+1],
274                stack_pointer[i+2],
275                stack_pointer[i+3]);
276     }
277 }
278 #endif
279
280 void
281 control_stack_exhausted_handler(int signal, siginfo_t *siginfo,
282                                 os_context_t *context) {
283     unblock_signals_in_context_and_maybe_warn(context);
284     arrange_return_to_lisp_function
285         (context, StaticSymbolFunction(CONTROL_STACK_EXHAUSTED_ERROR));
286 }
287
288 void
289 undefined_alien_handler(int signal, siginfo_t *siginfo, os_context_t *context) {
290     arrange_return_to_lisp_function
291         (context, StaticSymbolFunction(UNDEFINED_ALIEN_VARIABLE_ERROR));
292 }
293
294 kern_return_t
295 catch_exception_raise(mach_port_t exception_port,
296                       mach_port_t thread,
297                       mach_port_t task,
298                       exception_type_t exception,
299                       exception_data_t code_vector,
300                       mach_msg_type_number_t code_count)
301 {
302     kern_return_t ret;
303     int signal;
304     siginfo_t* siginfo;
305
306 #ifdef LISP_FEATURE_SB_THREAD
307     thread_mutex_lock(&mach_exception_lock);
308 #endif
309
310     x86_thread_state64_t thread_state;
311     mach_msg_type_number_t thread_state_count = x86_THREAD_STATE64_COUNT;
312
313     x86_float_state64_t float_state;
314     mach_msg_type_number_t float_state_count = x86_FLOAT_STATE64_COUNT;
315
316     x86_exception_state64_t exception_state;
317     mach_msg_type_number_t exception_state_count = x86_EXCEPTION_STATE64_COUNT;
318
319     x86_thread_state64_t backup_thread_state;
320     x86_thread_state64_t *target_thread_state;
321     x86_float_state64_t *target_float_state;
322
323     os_vm_address_t addr;
324
325     struct thread *th = (struct thread*) exception_port;
326
327     FSHOW((stderr,"/entering catch_exception_raise with exception: %d\n", exception));
328
329     switch (exception) {
330
331     case EXC_BAD_ACCESS:
332         signal = SIGBUS;
333         ret = thread_get_state(thread,
334                                x86_THREAD_STATE64,
335                                (thread_state_t)&thread_state,
336                                &thread_state_count);
337         ret = thread_get_state(thread,
338                                x86_FLOAT_STATE64,
339                                (thread_state_t)&float_state,
340                                &float_state_count);
341         ret = thread_get_state(thread,
342                                x86_EXCEPTION_STATE64,
343                                (thread_state_t)&exception_state,
344                                &exception_state_count);
345         addr = (void*)exception_state.faultvaddr;
346
347
348         /* note the os_context hackery here.  When the signal handler returns,
349          * it won't go back to what it was doing ... */
350         if(addr >= CONTROL_STACK_GUARD_PAGE(th) &&
351            addr < CONTROL_STACK_GUARD_PAGE(th) + os_vm_page_size) {
352             /* We hit the end of the control stack: disable guard page
353              * protection so the error handler has some headroom, protect the
354              * previous page so that we can catch returns from the guard page
355              * and restore it. */
356             protect_control_stack_guard_page(0, th);
357             protect_control_stack_return_guard_page(1, th);
358
359             backup_thread_state = thread_state;
360             open_stack_allocation(&thread_state);
361             /* Reserve a 256 byte zone for signal handlers
362              * to use on the interrupted thread stack.
363              */
364             stack_allocate(&thread_state, 256);
365
366             /* Save thread state */
367             target_thread_state =
368                 stack_allocate(&thread_state, sizeof(*target_thread_state));
369             (*target_thread_state) = backup_thread_state;
370
371             /* Save float state */
372             target_float_state =
373                 stack_allocate(&thread_state, sizeof(*target_float_state));
374             (*target_float_state) = float_state;
375
376             /* Set up siginfo */
377             siginfo = stack_allocate(&thread_state, sizeof(*siginfo));
378             /* what do we need to put in our fake siginfo?  It looks like
379              * the x86 code only uses si_signo and si_adrr. */
380             siginfo->si_signo = signal;
381             siginfo->si_addr = (void*)exception_state.faultvaddr;
382
383             call_c_function_in_context(&thread_state,
384                                        signal_emulation_wrapper,
385                                        5,
386                                        target_thread_state,
387                                        target_float_state,
388                                        signal,
389                                        siginfo,
390                                        control_stack_exhausted_handler);
391         }
392         else if(addr >= CONTROL_STACK_RETURN_GUARD_PAGE(th) &&
393                 addr < CONTROL_STACK_RETURN_GUARD_PAGE(th) + os_vm_page_size) {
394             /* We're returning from the guard page: reprotect it, and
395              * unprotect this one. This works even if we somehow missed
396              * the return-guard-page, and hit it on our way to new
397              * exhaustion instead. */
398             protect_control_stack_guard_page(1, th);
399             protect_control_stack_return_guard_page(0, th);
400         }
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);
406
407             /* Save thread state */
408             target_thread_state =
409                 stack_allocate(&thread_state, sizeof(*target_thread_state));
410             (*target_thread_state) = backup_thread_state;
411
412             target_float_state =
413                 stack_allocate(&thread_state, sizeof(*target_float_state));
414             (*target_float_state) = float_state;
415
416             /* Set up siginfo */
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;
422
423             call_c_function_in_context(&thread_state,
424                                        signal_emulation_wrapper,
425                                        5,
426                                        target_thread_state,
427                                        target_float_state,
428                                        signal,
429                                        siginfo,
430                                        undefined_alien_handler);
431         } else {
432
433             backup_thread_state = thread_state;
434             open_stack_allocation(&thread_state);
435             stack_allocate(&thread_state, 256);
436
437             /* Save thread state */
438             target_thread_state =
439                 stack_allocate(&thread_state, sizeof(*target_thread_state));
440             (*target_thread_state) = backup_thread_state;
441
442             target_float_state =
443                 stack_allocate(&thread_state, sizeof(*target_float_state));
444             (*target_float_state) = float_state;
445
446             /* Set up siginfo */
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;
452
453             call_c_function_in_context(&thread_state,
454                                        signal_emulation_wrapper,
455                                        5,
456                                        target_thread_state,
457                                        target_float_state,
458                                        signal,
459                                        siginfo,
460                                        memory_fault_handler);
461         }
462         ret = thread_set_state(thread,
463                                x86_THREAD_STATE64,
464                                (thread_state_t)&thread_state,
465                                thread_state_count);
466
467         ret = thread_set_state(thread,
468                                x86_FLOAT_STATE64,
469                                (thread_state_t)&float_state,
470                                float_state_count);
471 #ifdef LISP_FEATURE_SB_THREAD
472         thread_mutex_unlock(&mach_exception_lock);
473 #endif
474         return KERN_SUCCESS;
475
476     case EXC_BAD_INSTRUCTION:
477
478         ret = thread_get_state(thread,
479                                x86_THREAD_STATE64,
480                                (thread_state_t)&thread_state,
481                                &thread_state_count);
482         ret = thread_get_state(thread,
483                                x86_FLOAT_STATE64,
484                                (thread_state_t)&float_state,
485                                &float_state_count);
486         ret = thread_get_state(thread,
487                                x86_EXCEPTION_STATE64,
488                                (thread_state_t)&exception_state,
489                                &exception_state_count);
490         if (0xffffffffffff0b0f == *((u64 *)thread_state.rip)) {
491             /* fake sigreturn. */
492
493             /* When we get here, thread_state.rax is a pointer to a
494              * thread_state to restore. */
495             /* thread_state = *((thread_state_t *)thread_state.rax); */
496
497             ret = thread_set_state(thread,
498                                    x86_THREAD_STATE64,
499                                    (thread_state_t) thread_state.rax,
500                                    /* &thread_state, */
501                                    thread_state_count);
502
503             ret = thread_set_state(thread,
504                                    x86_FLOAT_STATE64,
505                                    (thread_state_t) thread_state.rbx,
506                                    /* &thread_state, */
507                                    float_state_count);
508         } else {
509
510             backup_thread_state = thread_state;
511             open_stack_allocation(&thread_state);
512             stack_allocate(&thread_state, 256);
513
514             /* Save thread state */
515             target_thread_state =
516                 stack_allocate(&thread_state, sizeof(*target_thread_state));
517             (*target_thread_state) = backup_thread_state;
518
519             target_float_state =
520                 stack_allocate(&thread_state, sizeof(*target_float_state));
521             (*target_float_state) = float_state;
522
523             /* Set up siginfo */
524             siginfo = stack_allocate(&thread_state, sizeof(*siginfo));
525             /* what do we need to put in our fake siginfo?  It looks like
526              * the x86 code only uses si_signo and si_adrr. */
527             if (*((unsigned short *)target_thread_state->rip) == 0x0b0f) {
528                 signal = SIGTRAP;
529                 siginfo->si_signo = signal;
530                 siginfo->si_addr = (void*)exception_state.faultvaddr;
531                 target_thread_state->rip += 2;
532                 call_c_function_in_context(&thread_state,
533                                            signal_emulation_wrapper,
534                                            5,
535                                            target_thread_state,
536                                            target_float_state,
537                                            signal,
538                                            siginfo,
539                                            sigtrap_handler);
540             } else {
541                 signal = SIGILL;
542                 siginfo->si_signo = signal;
543                 siginfo->si_addr = (void*)exception_state.faultvaddr;
544
545                 call_c_function_in_context(&thread_state,
546                                            signal_emulation_wrapper,
547                                            5,
548                                            target_thread_state,
549                                            target_float_state,
550                                            signal,
551                                            siginfo,
552                                            sigill_handler);
553             }
554             ret = thread_set_state(thread,
555                                    x86_THREAD_STATE64,
556                                    (thread_state_t)&thread_state,
557                                    thread_state_count);
558             ret = thread_set_state(thread,
559                                    x86_FLOAT_STATE64,
560                                    (thread_state_t)&float_state,
561                                    float_state_count);
562         }
563 #ifdef LISP_FEATURE_SB_THREAD
564         thread_mutex_unlock(&mach_exception_lock);
565 #endif
566         return KERN_SUCCESS;
567
568     default:
569 #ifdef LISP_FEATURE_SB_THREAD
570         thread_mutex_unlock(&mach_exception_lock);
571 #endif
572         return KERN_INVALID_RIGHT;
573     }
574 }
575
576 void *
577 mach_exception_handler(void *port)
578 {
579   mach_msg_server(exc_server, 2048, (mach_port_t) port, 0);
580   /* mach_msg_server should never return, but it should dispatch mach
581    * exceptions to our catch_exception_raise function
582    */
583   abort();
584 }
585
586 /* Sets up the thread that will listen for mach exceptions. note that
587    the exception handlers will be run on this thread. This is
588    different from the BSD-style signal handling situation in which the
589    signal handlers run in the relevant thread directly. */
590
591 mach_port_t mach_exception_handler_port_set = MACH_PORT_NULL;
592
593 pthread_t
594 setup_mach_exception_handling_thread()
595 {
596     kern_return_t ret;
597     pthread_t mach_exception_handling_thread = NULL;
598     pthread_attr_t attr;
599
600     /* allocate a mach_port for this process */
601     ret = mach_port_allocate(mach_task_self(),
602                              MACH_PORT_RIGHT_PORT_SET,
603                              &mach_exception_handler_port_set);
604
605     /* create the thread that will receive the mach exceptions */
606
607     FSHOW((stderr, "Creating mach_exception_handler thread!\n"));
608
609     pthread_attr_init(&attr);
610     pthread_create(&mach_exception_handling_thread,
611                    &attr,
612                    mach_exception_handler,
613                    (void*) mach_exception_handler_port_set);
614     pthread_attr_destroy(&attr);
615
616     return mach_exception_handling_thread;
617 }
618
619 /* tell the kernel that we want EXC_BAD_ACCESS exceptions sent to the
620    exception port (which is being listened to do by the mach
621    exception handling thread). */
622 kern_return_t
623 mach_thread_init(mach_port_t thread_exception_port)
624 {
625     kern_return_t ret;
626     /* allocate a named port for the thread */
627
628     FSHOW((stderr, "Allocating mach port %x\n", thread_exception_port));
629
630     ret = mach_port_allocate_name(mach_task_self(),
631                                   MACH_PORT_RIGHT_RECEIVE,
632                                   thread_exception_port);
633     if (ret) {
634         lose("mach_port_allocate_name failed with return_code %d\n", ret);
635     }
636
637     /* establish the right for the thread_exception_port to send messages */
638     ret = mach_port_insert_right(mach_task_self(),
639                                  thread_exception_port,
640                                  thread_exception_port,
641                                  MACH_MSG_TYPE_MAKE_SEND);
642     if (ret) {
643         lose("mach_port_insert_right failed with return_code %d\n", ret);
644     }
645
646     ret = thread_set_exception_ports(mach_thread_self(),
647                                      EXC_MASK_BAD_ACCESS | EXC_MASK_BAD_INSTRUCTION,
648                                      thread_exception_port,
649                                      EXCEPTION_DEFAULT,
650                                      THREAD_STATE_NONE);
651     if (ret) {
652         lose("thread_set_exception_port failed with return_code %d\n", ret);
653     }
654
655     ret = mach_port_move_member(mach_task_self(),
656                                 thread_exception_port,
657                                 mach_exception_handler_port_set);
658     if (ret) {
659         lose("mach_port_ failed with return_code %d\n", ret);
660     }
661
662     return ret;
663 }
664
665 void
666 setup_mach_exceptions() {
667     setup_mach_exception_handling_thread();
668     mach_thread_init(THREAD_STRUCT_TO_EXCEPTION_PORT(all_threads));
669 }
670
671 pid_t
672 mach_fork() {
673     pid_t pid = fork();
674     if (pid == 0) {
675         setup_mach_exceptions();
676         return pid;
677     } else {
678         return pid;
679     }
680 }
681
682 #endif