vm/mach_signal.cpp

   1 /* Fault handler information.  MacOSX version.
   2 Copyright (C) 1993-1999, 2002-2003  Bruno Haible <clisp.org at bruno>
   3
   4 Copyright (C) 2003  Paolo Bonzini <gnu.org at bonzini>
   5
   6 Used under BSD license with permission from Paolo Bonzini and Bruno Haible,
   7 2005-03-10:
   8
   9 http://sourceforge.net/mailarchive/message.php?msg_name=200503102200.32002.bruno%40clisp.org
  10
  11 Modified for Factor by Slava Pestov */
  12
  13 #include "master.hpp"
  14
  15 namespace factor
  16 {
  17
  18 /* The exception port on which our thread listens. */
  19 mach_port_t our_exception_port;
  20
  21 /* The following sources were used as a *reference* for this exception handling
  22 code:
  23 1. Apple's mach/xnu documentation
  24 2. Timothy J. Wood's "Mach Exception Handlers 101" post to the
  25 omnigroup's macosx-dev list.
  26 http://www.wodeveloper.com/omniLists/macosx-dev/2000/June/msg00137.html */
  27
  28 /* Modify a suspended thread's thread_state so that when the thread resumes
  29 executing, the call frame of the current C primitive (if any) is rewound, and
  30 the appropriate Factor error is thrown from the top-most Factor frame. */
  31 void factor_vm::call_fault_handler(
  32         exception_type_t exception,
  33         exception_data_type_t code,
  34         MACH_EXC_STATE_TYPE *exc_state,
  35         MACH_THREAD_STATE_TYPE *thread_state,
  36         MACH_FLOAT_STATE_TYPE *float_state)
  37 {
  38         /* There is a race condition here, but in practice an exception
  39         delivered during stack frame setup/teardown or while transitioning
  40         from Factor to C is a sign of things seriously gone wrong, not just
  41         a divide by zero or stack underflow in the listener */
  42
  43         /* Are we in compiled Factor code? Then use the current stack pointer */
  44         if(in_code_heap_p(MACH_PROGRAM_COUNTER(thread_state)))
  45                 signal_callstack_top = (stack_frame *)MACH_STACK_POINTER(thread_state);
  46         /* Are we in C? Then use the saved callstack top */
  47         else
  48                 signal_callstack_top = NULL;
  49
  50         MACH_STACK_POINTER(thread_state) = fix_stack_pointer(MACH_STACK_POINTER(thread_state));
  51
  52         /* Now we point the program counter at the right handler function. */
  53         if(exception == EXC_BAD_ACCESS)
  54         {
  55                 signal_fault_addr = MACH_EXC_STATE_FAULT(exc_state);
  56                 MACH_PROGRAM_COUNTER(thread_state) = (cell)factor::memory_signal_handler_impl;
  57         }
  58         else if(exception == EXC_ARITHMETIC && code != MACH_EXC_INTEGER_DIV)
  59         {
  60                 signal_fpu_status = fpu_status(mach_fpu_status(float_state));
  61                 mach_clear_fpu_status(float_state);
  62                 MACH_PROGRAM_COUNTER(thread_state) = (cell)factor::fp_signal_handler_impl;
  63         }
  64         else
  65         {
  66                 signal_number = (exception == EXC_ARITHMETIC ? SIGFPE : SIGABRT);
  67                 MACH_PROGRAM_COUNTER(thread_state) = (cell)factor::misc_signal_handler_impl;
  68         }
  69 }
  70
  71 static void call_fault_handler(
  72         mach_port_t thread,
  73         exception_type_t exception,
  74         exception_data_type_t code,
  75         MACH_EXC_STATE_TYPE *exc_state,
  76         MACH_THREAD_STATE_TYPE *thread_state,
  77         MACH_FLOAT_STATE_TYPE *float_state)
  78 {
  79         THREADHANDLE thread_id = pthread_from_mach_thread_np(thread);
  80         assert(thread_id);
  81         std::map<THREADHANDLE, factor_vm*>::const_iterator vm = thread_vms.find(thread_id);
  82         if (vm != thread_vms.end())
  83             vm->second->call_fault_handler(exception,code,exc_state,thread_state,float_state);
  84 }
  85
  86 /* Handle an exception by invoking the user's fault handler and/or forwarding
  87 the duty to the previously installed handlers.  */
  88 extern "C"
  89 kern_return_t
  90 catch_exception_raise (mach_port_t exception_port,
  91         mach_port_t thread,
  92         mach_port_t task,
  93         exception_type_t exception,
  94         exception_data_t code,
  95         mach_msg_type_number_t code_count)
  96 {
  97         MACH_EXC_STATE_TYPE exc_state;
  98         MACH_THREAD_STATE_TYPE thread_state;
  99         MACH_FLOAT_STATE_TYPE float_state;
 100         mach_msg_type_number_t exc_state_count, thread_state_count, float_state_count;
 101
 102         /* Get fault information and the faulting thread's register contents..
 103
 104         See http://web.mit.edu/darwin/src/modules/xnu/osfmk/man/thread_get_state.html.  */
 105         exc_state_count = MACH_EXC_STATE_COUNT;
 106         if (thread_get_state (thread, MACH_EXC_STATE_FLAVOR,
 107                               (natural_t *)&exc_state, &exc_state_count)
 108                 != KERN_SUCCESS)
 109         {
 110                 /* The thread is supposed to be suspended while the exception
 111                 handler is called. This shouldn't fail. */
 112                 return KERN_FAILURE;
 113         }
 114
 115         thread_state_count = MACH_THREAD_STATE_COUNT;
 116         if (thread_get_state (thread, MACH_THREAD_STATE_FLAVOR,
 117                               (natural_t *)&thread_state, &thread_state_count)
 118                 != KERN_SUCCESS)
 119         {
 120                 /* The thread is supposed to be suspended while the exception
 121                 handler is called. This shouldn't fail. */
 122                 return KERN_FAILURE;
 123         }
 124
 125         float_state_count = MACH_FLOAT_STATE_COUNT;
 126         if (thread_get_state (thread, MACH_FLOAT_STATE_FLAVOR,
 127                               (natural_t *)&float_state, &float_state_count)
 128                 != KERN_SUCCESS)
 129         {
 130                 /* The thread is supposed to be suspended while the exception
 131                 handler is called. This shouldn't fail. */
 132                 return KERN_FAILURE;
 133         }
 134
 135         /* Modify registers so to have the thread resume executing the
 136         fault handler */
 137         call_fault_handler(thread,exception,code[0],&exc_state,&thread_state,&float_state);
 138
 139         /* Set the faulting thread's register contents..
 140
 141         See http://web.mit.edu/darwin/src/modules/xnu/osfmk/man/thread_set_state.html.  */
 142         if (thread_set_state (thread, MACH_FLOAT_STATE_FLAVOR,
 143                               (natural_t *)&float_state, float_state_count)
 144                 != KERN_SUCCESS)
 145         {
 146                 return KERN_FAILURE;
 147         }
 148
 149         if (thread_set_state (thread, MACH_THREAD_STATE_FLAVOR,
 150                               (natural_t *)&thread_state, thread_state_count)
 151                 != KERN_SUCCESS)
 152         {
 153                 return KERN_FAILURE;
 154         }
 155
 156         return KERN_SUCCESS;
 157 }
 158
 159 /* The main function of the thread listening for exceptions.  */
 160 static void *
 161 mach_exception_thread (void *arg)
 162 {
 163         for (;;)
 164         {
 165                 /* These two structures contain some private kernel data. We don't need
 166                 to access any of it so we don't bother defining a proper struct. The
 167                 correct definitions are in the xnu source code. */
 168                 /* Buffer for a message to be received.  */
 169                 struct
 170                 {
 171                         mach_msg_header_t head;
 172                         mach_msg_body_t msgh_body;
 173                         char data[1024];
 174                 }
 175                 msg;
 176                 /* Buffer for a reply message.  */
 177                 struct
 178                 {
 179                         mach_msg_header_t head;
 180                         char data[1024];
 181                 }
 182                 reply;
 183
 184                 mach_msg_return_t retval;
 185
 186                 /* Wait for a message on the exception port.  */
 187                 retval = mach_msg (&msg.head, MACH_RCV_MSG | MACH_RCV_LARGE, 0,
 188                         sizeof (msg), our_exception_port,
 189                         MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
 190                 if (retval != MACH_MSG_SUCCESS)
 191                 {
 192                         abort ();
 193                 }
 194
 195                 /* Handle the message: Call exc_server, which will call
 196                 catch_exception_raise and produce a reply message.  */
 197                 exc_server (&msg.head, &reply.head);
 198
 199                 /* Send the reply.  */
 200                 if (mach_msg (&reply.head, MACH_SEND_MSG, reply.head.msgh_size,
 201                         0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL)
 202                         != MACH_MSG_SUCCESS)
 203                 {
 204                         abort ();
 205                 }
 206         }
 207 }
 208
 209 /* Initialize the Mach exception handler thread. */
 210 void mach_initialize ()
 211 {
 212         mach_port_t self;
 213         exception_mask_t mask;
 214
 215         self = mach_task_self ();
 216
 217         /* Allocate a port on which the thread shall listen for exceptions.  */
 218         if (mach_port_allocate (self, MACH_PORT_RIGHT_RECEIVE, &our_exception_port)
 219                 != KERN_SUCCESS)
 220                 fatal_error("mach_port_allocate() failed",0);
 221
 222         /* See http://web.mit.edu/darwin/src/modules/xnu/osfmk/man/mach_port_insert_right.html.  */
 223         if (mach_port_insert_right (self, our_exception_port, our_exception_port,
 224                 MACH_MSG_TYPE_MAKE_SEND)
 225                 != KERN_SUCCESS)
 226                 fatal_error("mach_port_insert_right() failed",0);
 227
 228         /* The exceptions we want to catch. */
 229         mask = EXC_MASK_BAD_ACCESS | EXC_MASK_ARITHMETIC;
 230
 231         /* Create the thread listening on the exception port.  */
 232         start_thread(mach_exception_thread,NULL);
 233
 234         /* Replace the exception port info for these exceptions with our own.
 235         Note that we replace the exception port for the entire task, not only
 236         for a particular thread.  This has the effect that when our exception
 237         port gets the message, the thread specific exception port has already
 238         been asked, and we don't need to bother about it.
 239         See http://web.mit.edu/darwin/src/modules/xnu/osfmk/man/task_set_exception_ports.html.  */
 240         if (task_set_exception_ports (self, mask, our_exception_port,
 241                 EXCEPTION_DEFAULT, MACHINE_THREAD_STATE)
 242                 != KERN_SUCCESS)
 243                 fatal_error("task_set_exception_ports() failed",0);
 244 }
 245
 246 }