hurd/hurdfault.c

   1 /* Handle faults in the signal thread.
   2    Copyright (C) 1994,1995,1996,1997,2002,2005
   3         Free Software Foundation, Inc.
   4    This file is part of the GNU C Library.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #include <hurd.h>
  22 #include <hurd/signal.h>
  23 #include "hurdfault.h"
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <setjmp.h>
  27 #include <stdio.h>
  28 #include <thread_state.h>
  29 #include "faultexc_server.h"    /* mig-generated header for our exc server.  */
  30 #include <assert.h>
  31
  32 jmp_buf _hurdsig_fault_env;
  33 struct hurd_signal_preemptor _hurdsig_fault_preemptor = {0};
  34
  35 /* XXX temporary to deal with spelling fix */
  36 weak_alias (_hurdsig_fault_preemptor, _hurdsig_fault_preempter)
  37
  38 static mach_port_t forward_sigexc;
  39
  40 kern_return_t
  41 _hurdsig_fault_catch_exception_raise (mach_port_t port,
  42                                       thread_t thread,
  43                                       task_t task,
  44 #ifdef EXC_MASK_ALL             /* New interface flavor.  */
  45                                       exception_type_t exception,
  46                                       exception_data_t code,
  47                                       mach_msg_type_number_t codeCnt
  48 #else                           /* Vanilla Mach 3.0 interface.  */
  49                                       integer_t exception,
  50                                       integer_t code, integer_t subcode
  51 #endif
  52                                       )
  53 {
  54   int signo;
  55   struct hurd_signal_detail d;
  56
  57   if (port != forward_sigexc ||
  58       thread != _hurd_msgport_thread || task != __mach_task_self ())
  59     return EPERM;               /* Strange bogosity.  */
  60
  61   d.exc = exception;
  62 #ifdef EXC_MASK_ALL
  63   assert (codeCnt >= 2);
  64   d.exc_code = code[0];
  65   d.exc_subcode = code[1];
  66 #else
  67   d.exc_code = code;
  68   d.exc_subcode = subcode;
  69 #endif
  70
  71   /* Call the machine-dependent function to translate the Mach exception
  72      codes into a signal number and subcode.  */
  73   _hurd_exception2signal (&d, &signo);
  74
  75   return HURD_PREEMPT_SIGNAL_P (&_hurdsig_fault_preemptor, signo, d.code)
  76     ? 0 : EGREGIOUS;
  77 }
  78
  79 #ifdef EXC_MASK_ALL
  80 /* XXX New interface flavor has additional RPCs that we could be using
  81    instead.  These RPCs roll a thread_get_state/thread_set_state into
  82    the message, so the signal thread ought to use these to save some calls.
  83  */
  84 kern_return_t
  85 _hurdsig_fault_catch_exception_raise_state
  86 (mach_port_t port,
  87  exception_type_t exception,
  88  exception_data_t code,
  89  mach_msg_type_number_t codeCnt,
  90  int *flavor,
  91  thread_state_t old_state,
  92  mach_msg_type_number_t old_stateCnt,
  93  thread_state_t new_state,
  94  mach_msg_type_number_t *new_stateCnt)
  95 {
  96   abort ();
  97   return KERN_FAILURE;
  98 }
  99
 100 kern_return_t
 101 _hurdsig_fault_catch_exception_raise_state_identity
 102 (mach_port_t exception_port,
 103  thread_t thread,
 104  task_t task,
 105  exception_type_t exception,
 106  exception_data_t code,
 107  mach_msg_type_number_t codeCnt,
 108  int *flavor,
 109  thread_state_t old_state,
 110  mach_msg_type_number_t old_stateCnt,
 111  thread_state_t new_state,
 112  mach_msg_type_number_t *new_stateCnt)
 113 {
 114   abort ();
 115   return KERN_FAILURE;
 116 }
 117 #endif
 118
 119
 120 #ifdef NDR_CHAR_ASCII           /* OSF Mach flavors have different names.  */
 121 # define mig_reply_header_t     mig_reply_error_t
 122 #endif
 123
 124 static void
 125 faulted (void)
 126 {
 127   struct
 128     {
 129       mach_msg_header_t head;
 130       char buf[64];
 131     } request;
 132   mig_reply_header_t reply;
 133   extern int _hurdsig_fault_exc_server (mach_msg_header_t *,
 134                                         mach_msg_header_t *);
 135
 136  /* Wait for the exception_raise message forwarded by the proc server.  */
 137
 138  if (__mach_msg (&request.head, MACH_RCV_MSG, 0,
 139                   sizeof request, forward_sigexc,
 140                   MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL)
 141       != MACH_MSG_SUCCESS)
 142     __libc_fatal ("msg receive failed on signal thread exc\n");
 143
 144   /* Run the exc demuxer which should call the server function above.
 145      That function returns 0 if the exception was expected.  */
 146   _hurdsig_fault_exc_server (&request.head, &reply.Head);
 147   if (reply.Head.msgh_remote_port != MACH_PORT_NULL)
 148     __mach_msg (&reply.Head, MACH_SEND_MSG, reply.Head.msgh_size,
 149                 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
 150   if (reply.RetCode == MIG_BAD_ID)
 151     __mach_msg_destroy (&request.head);
 152
 153   if (reply.RetCode)
 154     __libc_fatal ("BUG: unexpected fault in signal thread\n");
 155
 156   _hurdsig_fault_preemptor.signals = 0;
 157   longjmp (_hurdsig_fault_env, 1);
 158 }
 159
 160 static char faultstack[1024];
 161
 162 /* Send exceptions for the signal thread to the proc server.
 163    It will forward the message on to our message port,
 164    and then restore the thread's state to code which
 165    does `longjmp (_hurd_sigthread_fault_env, 1)'.  */
 166
 167 void
 168 _hurdsig_fault_init (void)
 169 {
 170   error_t err;
 171   struct machine_thread_state state;
 172   mach_port_t sigexc;
 173
 174   /* Allocate a port to receive signal thread exceptions.
 175      We will move this receive right to the proc server.  */
 176   err = __mach_port_allocate (__mach_task_self (),
 177                               MACH_PORT_RIGHT_RECEIVE, &sigexc);
 178   assert_perror (err);
 179   err = __mach_port_allocate (__mach_task_self (),
 180                               MACH_PORT_RIGHT_RECEIVE, &forward_sigexc);
 181   assert_perror (err);
 182
 183   /* Allocate a port to receive the exception msgs forwarded
 184      from the proc server.  */
 185   err = __mach_port_insert_right (__mach_task_self (), sigexc,
 186                                   sigexc, MACH_MSG_TYPE_MAKE_SEND);
 187   assert_perror (err);
 188
 189   /* Set the queue limit for this port to just one.  The proc server will
 190      notice if we ever get a second exception while one remains queued and
 191      unreceived, and decide we are hopelessly buggy.  */
 192 #ifdef MACH_PORT_RECEIVE_STATUS_COUNT
 193   {
 194     const mach_port_limits_t lim = { mpl_qlimit: 1 };
 195     assert (MACH_PORT_RECEIVE_STATUS_COUNT == sizeof lim / sizeof (natural_t));
 196     err = __mach_port_set_attributes (__mach_task_self (), forward_sigexc,
 197                                       MACH_PORT_RECEIVE_STATUS,
 198                                       (mach_port_info_t) &lim,
 199                                       MACH_PORT_RECEIVE_STATUS_COUNT);
 200   }
 201 #else
 202   err = __mach_port_set_qlimit (__mach_task_self (), forward_sigexc, 1);
 203 #endif
 204   assert_perror (err);
 205
 206   /* This state will be restored when we fault.
 207      It runs the function above.  */
 208   memset (&state, 0, sizeof state);
 209   MACHINE_THREAD_STATE_SET_PC (&state, faulted);
 210   MACHINE_THREAD_STATE_SET_SP (&state, faultstack, sizeof faultstack);
 211
 212   err = __USEPORT
 213     (PROC,
 214      __proc_handle_exceptions (port,
 215                                sigexc,
 216                                forward_sigexc, MACH_MSG_TYPE_MAKE_SEND,
 217                                MACHINE_THREAD_STATE_FLAVOR,
 218                                (natural_t *) &state,
 219                                MACHINE_THREAD_STATE_COUNT));
 220   assert_perror (err);
 221
 222   /* Direct signal thread exceptions to the proc server.  */
 223 #ifdef THREAD_EXCEPTION_PORT
 224   err = __thread_set_special_port (_hurd_msgport_thread,
 225                                    THREAD_EXCEPTION_PORT, sigexc);
 226 #elif defined (EXC_MASK_ALL)
 227   __thread_set_exception_ports (_hurd_msgport_thread,
 228                                 EXC_MASK_ALL & ~(EXC_MASK_SYSCALL
 229                                                  | EXC_MASK_MACH_SYSCALL
 230                                                  | EXC_MASK_RPC_ALERT),
 231                                 sigexc,
 232                                 EXCEPTION_STATE_IDENTITY,
 233                                 MACHINE_THREAD_STATE);
 234 #else
 235 # error thread_set_exception_ports?
 236 #endif
 237   __mach_port_deallocate (__mach_task_self (), sigexc);
 238   assert_perror (err);
 239 }