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