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