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