hurd/hurdfault.c

   1 /* Handle faults in the signal thread.
   2 Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
   3 This file is part of the GNU C Library.
   4
   5 The GNU C Library is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU Library General Public License as
   7 published by the Free Software Foundation; either version 2 of the
   8 License, or (at your option) any later version.
   9
  10 The GNU C Library is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 Library General Public License for more details.
  14
  15 You should have received a copy of the GNU Library General Public
  16 License along with the GNU C Library; see the file COPYING.LIB.  If
  17 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  18 Cambridge, MA 02139, USA.  */
  19
  20 #include <hurd.h>
  21 #include <hurd/signal.h>
  22 #include "hurdfault.h"
  23 #include <errno.h>
  24 #include <string.h>
  25 #include <setjmp.h>
  26 #include <stdio.h>
  27 #include "thread_state.h"
  28 #include "faultexc_server.h"    /* mig-generated header for our exc server.  */
  29 #include <assert.h>
  30
  31 jmp_buf _hurdsig_fault_env;
  32 struct hurd_signal_preempter _hurdsig_fault_preempter;
  33
  34 static mach_port_t forward_sigexc;
  35
  36 kern_return_t
  37 _hurdsig_fault_catch_exception_raise (mach_port_t port,
  38                                       thread_t thread,
  39                                       task_t task,
  40                                       int exception,
  41                                       int code,
  42                                       int subcode)
  43 {
  44   int signo;
  45   struct hurd_signal_detail d;
  46
  47   if (port != forward_sigexc ||
  48       thread != _hurd_msgport_thread || task != __mach_task_self ())
  49     return EPERM;               /* Strange bogosity.  */
  50
  51   d.exc = exception;
  52   d.exc_code = code;
  53   d.exc_subcode = subcode;
  54
  55   /* Call the machine-dependent function to translate the Mach exception
  56      codes into a signal number and subcode.  */
  57   _hurd_exception2signal (&d, &signo);
  58
  59   return HURD_PREEMPT_SIGNAL_P (&_hurdsig_fault_preempter, signo, d.code)
  60     ? 0 : EGREGIOUS;
  61 }
  62
  63 static void
  64 faulted (void)
  65 {
  66   struct
  67     {
  68       mach_msg_header_t head;
  69       char buf[64];
  70     } request;
  71   struct
  72     {
  73       mach_msg_header_t head;
  74       mach_msg_type_t type;
  75       int result;
  76     } reply;
  77   extern int _hurdsig_fault_exc_server (mach_msg_header_t *,
  78                                         mach_msg_header_t *);
  79
  80  /* Wait for the exception_raise message forwarded by the proc server.  */
  81
  82  if (__mach_msg (&request.head, MACH_RCV_MSG, 0,
  83                   sizeof request, forward_sigexc,
  84                   MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL)
  85       != MACH_MSG_SUCCESS)
  86     __libc_fatal ("msg receive failed on signal thread exc\n");
  87
  88   /* Run the exc demuxer which should call the server function above.
  89      That function returns 0 if the exception was expected.  */
  90   _hurdsig_fault_exc_server (&request.head, &reply.head);
  91   if (reply.head.msgh_remote_port != MACH_PORT_NULL)
  92     __mach_msg (&reply.head, MACH_SEND_MSG, reply.head.msgh_size,
  93                 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
  94   if (reply.result == MIG_BAD_ID)
  95     __mach_msg_destroy (&request.head);
  96
  97   if (reply.result)
  98     __libc_fatal ("BUG: unexpected fault in signal thread\n");
  99
 100   _hurdsig_fault_preempter.signals = 0;
 101   longjmp (_hurdsig_fault_env, 1);
 102 }
 103
 104 static char faultstack[1024];
 105
 106 /* Send exceptions for the signal thread to the proc server.
 107    It will forward the message on to our message port,
 108    and then restore the thread's state to code which
 109    does `longjmp (_hurd_sigthread_fault_env, 1)'.  */
 110
 111 void
 112 _hurdsig_fault_init (void)
 113 {
 114   error_t err;
 115   struct machine_thread_state state;
 116   mach_port_t sigexc;
 117
 118   /* Allocate a port to receive signal thread exceptions.
 119      We will move this receive right to the proc server.  */
 120   err = __mach_port_allocate (__mach_task_self (),
 121                               MACH_PORT_RIGHT_RECEIVE, &sigexc);
 122   assert_perror (err);
 123   err = __mach_port_allocate (__mach_task_self (),
 124                               MACH_PORT_RIGHT_RECEIVE, &forward_sigexc);
 125   assert_perror (err);
 126
 127   /* Allocate a port to receive the exception msgs forwarded
 128      from the proc server.  */
 129   err = __mach_port_insert_right (__mach_task_self (), sigexc,
 130                                   sigexc, MACH_MSG_TYPE_MAKE_SEND);
 131   assert_perror (err);
 132
 133   /* Set the queue limit for this port to just one.  The proc server will
 134      notice if we ever get a second exception while one remains queued and
 135      unreceived, and decide we are hopelessly buggy.  */
 136   err = __mach_port_set_qlimit (__mach_task_self (), forward_sigexc, 1);
 137   assert_perror (err);
 138
 139   /* This state will be restored when we fault.
 140      It runs the function above.  */
 141   memset (&state, 0, sizeof state);
 142   MACHINE_THREAD_STATE_SET_PC (&state, faulted);
 143   MACHINE_THREAD_STATE_SET_SP (&state, faultstack, sizeof faultstack);
 144
 145   err = __USEPORT
 146     (PROC,
 147      __proc_handle_exceptions (port,
 148                                sigexc,
 149                                forward_sigexc, MACH_MSG_TYPE_MAKE_SEND,
 150                                MACHINE_THREAD_STATE_FLAVOR,
 151                                (natural_t *) &state,
 152                                MACHINE_THREAD_STATE_COUNT));
 153   assert_perror (err);
 154
 155   /* Direct signal thread exceptions to the proc server.  */
 156   err = __thread_set_special_port (_hurd_msgport_thread,
 157                                    THREAD_EXCEPTION_PORT, sigexc);
 158   __mach_port_deallocate (__mach_task_self (), sigexc);
 159   assert_perror (err);
 160 }
 161