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) = align_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                 switch(exception)
  67                 {
  68                 case EXC_ARITHMETIC: signal_number = SIGFPE; break;
  69                 case EXC_BAD_INSTRUCTION: signal_number = SIGILL; break;
  70                 default: signal_number = SIGABRT; break;
  71                 }
  72
  73                 MACH_PROGRAM_COUNTER(thread_state) = (cell)factor::misc_signal_handler_impl;
  74         }
  75 }
  76
  77 static void call_fault_handler(
  78         mach_port_t thread,
  79         exception_type_t exception,
  80         exception_data_type_t code,
  81         MACH_EXC_STATE_TYPE *exc_state,
  82         MACH_THREAD_STATE_TYPE *thread_state,
  83         MACH_FLOAT_STATE_TYPE *float_state)
  84 {
  85         /* Look up the VM instance involved */
  86         THREADHANDLE thread_id = pthread_from_mach_thread_np(thread);
  87         assert(thread_id);
  88         std::map<THREADHANDLE, factor_vm*>::const_iterator vm = thread_vms.find(thread_id);
  89
  90         /* Handle the exception */
  91         if (vm != thread_vms.end())
  92                 vm->second->call_fault_handler(exception,code,exc_state,thread_state,float_state);
  93 }
  94
  95 /* Handle an exception by invoking the user's fault handler and/or forwarding
  96 the duty to the previously installed handlers.  */
  97 extern "C"
  98 kern_return_t
  99 catch_exception_raise (mach_port_t exception_port,
 100         mach_port_t thread,
 101         mach_port_t task,
 102         exception_type_t exception,
 103         exception_data_t code,
 104         mach_msg_type_number_t code_count)
 105 {
 106         /* 10.6 likes to report exceptions from child processes too. Ignore those */
 107         if(task != mach_task_self()) return KERN_FAILURE;
 108
 109         /* Get fault information and the faulting thread's register contents..
 110
 111         See http://web.mit.edu/darwin/src/modules/xnu/osfmk/man/thread_get_state.html.  */
 112         MACH_EXC_STATE_TYPE exc_state;
 113         mach_msg_type_number_t exc_state_count = MACH_EXC_STATE_COUNT;
 114         if (thread_get_state (thread, MACH_EXC_STATE_FLAVOR,
 115                               (natural_t *)&exc_state, &exc_state_count)
 116                 != KERN_SUCCESS)
 117         {
 118                 /* The thread is supposed to be suspended while the exception
 119                 handler is called. This shouldn't fail. */
 120                 return KERN_FAILURE;
 121         }
 122
 123         MACH_THREAD_STATE_TYPE thread_state;
 124         mach_msg_type_number_t thread_state_count = MACH_THREAD_STATE_COUNT;
 125         if (thread_get_state (thread, MACH_THREAD_STATE_FLAVOR,
 126                               (natural_t *)&thread_state, &thread_state_count)
 127                 != KERN_SUCCESS)
 128         {
 129                 /* The thread is supposed to be suspended while the exception
 130                 handler is called. This shouldn't fail. */
 131                 return KERN_FAILURE;
 132         }
 133
 134         MACH_FLOAT_STATE_TYPE float_state;
 135         mach_msg_type_number_t float_state_count = MACH_FLOAT_STATE_COUNT;
 136         if (thread_get_state (thread, MACH_FLOAT_STATE_FLAVOR,
 137                               (natural_t *)&float_state, &float_state_count)
 138                 != KERN_SUCCESS)
 139         {
 140                 /* The thread is supposed to be suspended while the exception
 141                 handler is called. This shouldn't fail. */
 142                 return KERN_FAILURE;
 143         }
 144
 145         /* Modify registers so to have the thread resume executing the
 146         fault handler */
 147         call_fault_handler(thread,exception,code[0],&exc_state,&thread_state,&float_state);
 148
 149         /* Set the faulting thread's register contents..
 150
 151         See http://web.mit.edu/darwin/src/modules/xnu/osfmk/man/thread_set_state.html.  */
 152         if (thread_set_state (thread, MACH_FLOAT_STATE_FLAVOR,
 153                               (natural_t *)&float_state, float_state_count)
 154                 != KERN_SUCCESS)
 155         {
 156                 return KERN_FAILURE;
 157         }
 158
 159         if (thread_set_state (thread, MACH_THREAD_STATE_FLAVOR,
 160                               (natural_t *)&thread_state, thread_state_count)
 161                 != KERN_SUCCESS)
 162         {
 163                 return KERN_FAILURE;
 164         }
 165
 166         return KERN_SUCCESS;
 167 }
 168
 169 /* The main function of the thread listening for exceptions.  */
 170 static void *
 171 mach_exception_thread (void *arg)
 172 {
 173         for (;;)
 174         {
 175                 /* These two structures contain some private kernel data. We don't need
 176                 to access any of it so we don't bother defining a proper struct. The
 177                 correct definitions are in the xnu source code. */
 178                 /* Buffer for a message to be received.  */
 179                 struct
 180                 {
 181                         mach_msg_header_t head;
 182                         mach_msg_body_t msgh_body;
 183                         char data[1024];
 184                 }
 185                 msg;
 186                 /* Buffer for a reply message.  */
 187                 struct
 188                 {
 189                         mach_msg_header_t head;
 190                         char data[1024];
 191                 }
 192                 reply;
 193
 194                 mach_msg_return_t retval;
 195
 196                 /* Wait for a message on the exception port.  */
 197                 retval = mach_msg (&msg.head, MACH_RCV_MSG | MACH_RCV_LARGE, 0,
 198                         sizeof (msg), our_exception_port,
 199                         MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
 200                 if (retval != MACH_MSG_SUCCESS)
 201                 {
 202                         abort ();
 203                 }
 204
 205                 /* Handle the message: Call exc_server, which will call
 206                 catch_exception_raise and produce a reply message.  */
 207                 exc_server (&msg.head, &reply.head);
 208
 209                 /* Send the reply.  */
 210                 if (mach_msg (&reply.head, MACH_SEND_MSG, reply.head.msgh_size,
 211                         0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL)
 212                         != MACH_MSG_SUCCESS)
 213                 {
 214                         abort ();
 215                 }
 216         }
 217 }
 218
 219 /* Initialize the Mach exception handler thread. */
 220 void mach_initialize ()
 221 {
 222         mach_port_t self;
 223         exception_mask_t mask;
 224
 225         self = mach_task_self ();
 226
 227         /* Allocate a port on which the thread shall listen for exceptions.  */
 228         if (mach_port_allocate (self, MACH_PORT_RIGHT_RECEIVE, &our_exception_port)
 229                 != KERN_SUCCESS)
 230                 fatal_error("mach_port_allocate() failed",0);
 231
 232         /* See http://web.mit.edu/darwin/src/modules/xnu/osfmk/man/mach_port_insert_right.html.  */
 233         if (mach_port_insert_right (self, our_exception_port, our_exception_port,
 234                 MACH_MSG_TYPE_MAKE_SEND)
 235                 != KERN_SUCCESS)
 236                 fatal_error("mach_port_insert_right() failed",0);
 237
 238         /* The exceptions we want to catch. */
 239         mask = EXC_MASK_BAD_ACCESS | EXC_MASK_BAD_INSTRUCTION | EXC_MASK_ARITHMETIC;
 240
 241         /* Create the thread listening on the exception port.  */
 242         start_thread(mach_exception_thread,NULL);
 243
 244         /* Replace the exception port info for these exceptions with our own.
 245         Note that we replace the exception port for the entire task, not only
 246         for a particular thread.  This has the effect that when our exception
 247         port gets the message, the thread specific exception port has already
 248         been asked, and we don't need to bother about it.
 249         See http://web.mit.edu/darwin/src/modules/xnu/osfmk/man/task_set_exception_ports.html.  */
 250         if (task_set_exception_ports (self, mask, our_exception_port,
 251                 EXCEPTION_DEFAULT, MACHINE_THREAD_STATE)
 252                 != KERN_SUCCESS)
 253                 fatal_error("task_set_exception_ports() failed",0);
 254 }
 255
 256 }