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