|
3092
|
1 /* Virtual diry bit implementation for XEmacs.
|
|
|
2 Copyright (C) 2005 Marcus Crestani.
|
|
|
3
|
|
|
4 This file is part of XEmacs.
|
|
|
5
|
|
|
6 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
7 under the terms of the GNU General Public License as published by the
|
|
|
8 Free Software Foundation; either version 2, or (at your option) any
|
|
|
9 later version.
|
|
|
10
|
|
|
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
14 for more details.
|
|
|
15
|
|
|
16 You should have received a copy of the GNU General Public License
|
|
|
17 along with XEmacs; see the file COPYING. If not, write to
|
|
|
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
19 Boston, MA 02111-1307, USA. */
|
|
|
20
|
|
|
21 /* Synched up with: Not in FSF. */
|
|
|
22
|
|
|
23 #include <config.h>
|
|
|
24 #include "lisp.h"
|
|
|
25 #include "gc.h"
|
|
|
26 #include "mc-alloc.h"
|
|
|
27 #include "vdb.h"
|
|
|
28
|
|
|
29 #include <errno.h>
|
|
|
30 #include <signal.h>
|
|
|
31 #include <sys/mman.h>
|
|
|
32 #include <sys/time.h>
|
|
|
33 #include <sys/resource.h>
|
|
|
34 #include <unistd.h>
|
|
|
35 #include <mach/mach.h>
|
|
|
36 #include <mach/mach_error.h>
|
|
|
37 #include <architecture/ppc/cframe.h>
|
|
|
38
|
|
|
39
|
|
|
40 /* the structure of an exception msg and its reply */
|
|
|
41 typedef struct rep_msg {
|
|
|
42 mach_msg_header_t head;
|
|
|
43 NDR_record_t NDR;
|
|
|
44 kern_return_t ret_code;
|
|
|
45 } mach_reply_msg_t;
|
|
|
46
|
|
|
47 typedef struct exc_msg {
|
|
|
48 mach_msg_header_t head;
|
|
|
49 /* start of the kernel processed data */
|
|
|
50 mach_msg_body_t msgh_body;
|
|
|
51 mach_msg_port_descriptor_t thread;
|
|
|
52 mach_msg_port_descriptor_t task;
|
|
|
53 /* end of the kernel processed data */
|
|
|
54 NDR_record_t NDR;
|
|
|
55 exception_type_t exception;
|
|
|
56 mach_msg_type_number_t code_cnt;
|
|
|
57 exception_data_t code;
|
|
|
58 /* some padding */
|
|
|
59 char pad[512];
|
|
|
60 } mach_exc_msg_t;
|
|
|
61
|
|
|
62 /* this is a neat little mach callback */
|
|
|
63 extern boolean_t exc_server(mach_msg_header_t *in, mach_msg_header_t *out);
|
|
|
64
|
|
|
65 /* these are the globals everyone needs */
|
|
|
66 static size_t page_size = 16384;
|
|
|
67 static mach_port_t task_self = NULL;
|
|
|
68 static mach_port_t exc_port = NULL;
|
|
|
69
|
|
|
70 /* these are some less neat mach callbacks */
|
|
|
71 kern_return_t
|
|
|
72 catch_exception_raise_state
|
|
|
73 (mach_port_t UNUSED (port),
|
|
|
74 exception_type_t UNUSED (exception_type),
|
|
|
75 exception_data_t UNUSED (exception_data),
|
|
|
76 mach_msg_type_number_t UNUSED (data_cnt),
|
|
|
77 thread_state_flavor_t *UNUSED (flavor),
|
|
|
78 thread_state_t UNUSED (in_state),
|
|
|
79 mach_msg_type_number_t UNUSED (is_cnt),
|
|
|
80 thread_state_t UNUSED (out_state),
|
|
|
81 mach_msg_type_number_t UNUSED (os_cnt))
|
|
|
82 {
|
|
|
83 return KERN_FAILURE;
|
|
|
84 }
|
|
|
85
|
|
|
86 kern_return_t
|
|
|
87 catch_exception_raise_state_identitity
|
|
|
88 (mach_port_t UNUSED (port),
|
|
|
89 mach_port_t UNUSED (thread_port),
|
|
|
90 mach_port_t UNUSED (task_port),
|
|
|
91 exception_type_t UNUSED (exception_type),
|
|
|
92 exception_data_t UNUSED (exception_data),
|
|
|
93 mach_msg_type_number_t UNUSED (data_count),
|
|
|
94 thread_state_flavor_t *UNUSED (state_flavor),
|
|
|
95 thread_state_t UNUSED (in_state),
|
|
|
96 mach_msg_type_number_t UNUSED (in_state_count),
|
|
|
97 thread_state_t UNUSED (out_state),
|
|
|
98 mach_msg_type_number_t UNUSED (out_state_count))
|
|
|
99 {
|
|
|
100 return KERN_FAILURE;
|
|
|
101 }
|
|
|
102
|
|
|
103 kern_return_t
|
|
|
104 catch_exception_raise
|
|
|
105 (mach_port_t UNUSED (port),
|
|
|
106 mach_port_t UNUSED (thread_port),
|
|
|
107 mach_port_t UNUSED (task_port),
|
|
|
108 exception_type_t UNUSED (exception_type),
|
|
|
109 exception_data_t exception_data,
|
|
|
110 mach_msg_type_number_t UNUSED (data_count))
|
|
|
111 {
|
|
|
112 /* kernel return value is in exception_data[0], faulting address in
|
|
|
113 exception_data[1] */
|
|
|
114 if (write_barrier_enabled
|
|
|
115 && (fault_on_protected_page ((void *) exception_data[1]))
|
|
|
116 && exception_data[0] == KERN_PROTECTION_FAILURE)
|
|
|
117 {
|
|
|
118 vdb_designate_modified ((void *) exception_data[1]);
|
|
|
119 unprotect_page_and_mark_dirty ((void *) exception_data[1]);
|
|
|
120 return KERN_SUCCESS;
|
|
|
121 }
|
|
|
122 else /* default sigsegv handler */
|
|
|
123 {
|
|
|
124 fprintf (stderr, "\n\nFatal Error: Received %s (%d) for address 0x%x\n",
|
|
|
125 "EXC_BAD_ACCESS", exception_data[0], (int) exception_data[1]);
|
|
|
126 return KERN_FAILURE;
|
|
|
127 }
|
|
|
128 }
|
|
|
129
|
|
|
130 /* this is the thread which forwards of exceptions read from the exception
|
|
|
131 server off to our exception catchers and then back out to the other
|
|
|
132 thread */
|
|
|
133 void
|
|
|
134 exception_thread(void)
|
|
|
135 {
|
|
|
136 mach_msg_header_t *message;
|
|
|
137 mach_msg_header_t *reply;
|
|
|
138 kern_return_t retval;
|
|
|
139
|
|
|
140 /* allocate the space for the message and reply */
|
|
|
141 message = (mach_msg_header_t *) malloc (sizeof (mach_exc_msg_t));
|
|
|
142 reply = (mach_msg_header_t *) malloc (sizeof (mach_reply_msg_t));
|
|
|
143 /* do this loop forever */
|
|
|
144 while (1)
|
|
|
145 {
|
|
|
146 /* block until we get an exception message */
|
|
|
147 retval = mach_msg (message, MACH_RCV_MSG, 0, sizeof (mach_exc_msg_t),
|
|
|
148 exc_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
|
|
|
149 /* forward off the handling of this message */
|
|
|
150 if (!exc_server (message, reply))
|
|
|
151 {
|
|
|
152 fprintf (stderr, "INTERNAL ERROR: exc_server() failed.\n");
|
|
|
153 ABORT ();
|
|
|
154 }
|
|
|
155 /* send the message back out to the thread */
|
|
|
156 retval = mach_msg (reply, MACH_SEND_MSG, sizeof (mach_reply_msg_t), 0,
|
|
|
157 MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
|
|
|
158 MACH_PORT_NULL);
|
|
|
159 }
|
|
|
160 }
|
|
|
161
|
|
|
162 /* this initializes the subsystem (sets the exception port, starts the
|
|
|
163 exception handling thread, etc) */
|
|
|
164 void
|
|
|
165 vdb_install_signal_handler (void)
|
|
|
166 {
|
|
|
167 mach_port_t thread_self, exc_port_s, exc_thread;
|
|
|
168 ppc_thread_state_t *exc_thread_state;
|
|
|
169 mach_msg_type_name_t type;
|
|
|
170 void *subthread_stack;
|
|
|
171 kern_return_t retval;
|
|
|
172
|
|
|
173 /* get ids for ourself */
|
|
|
174 if (!task_self)
|
|
|
175 task_self = mach_task_self ();
|
|
|
176 thread_self = mach_thread_self ();
|
|
|
177
|
|
|
178 /* allocate the port we're going to get exceptions on */
|
|
|
179 retval = mach_port_allocate (task_self, MACH_PORT_RIGHT_RECEIVE, &exc_port);
|
|
|
180 if (retval != KERN_SUCCESS)
|
|
|
181 {
|
|
|
182 fprintf (stderr, "Couldn't allocate exception port: %s\n",
|
|
|
183 mach_error_string (retval));
|
|
|
184 ABORT ();
|
|
|
185 }
|
|
|
186
|
|
|
187 /* extract out the send rights for that port, which the OS needs */
|
|
|
188 retval = mach_port_extract_right (task_self, exc_port,
|
|
|
189 MACH_MSG_TYPE_MAKE_SEND,
|
|
|
190 &exc_port_s, &type);
|
|
|
191 if(retval != KERN_SUCCESS)
|
|
|
192 {
|
|
|
193 fprintf (stderr, "Couldn't extract send rights: %s\n",
|
|
|
194 mach_error_string (retval));
|
|
|
195 ABORT ();
|
|
|
196 }
|
|
|
197
|
|
|
198 /* set the exception ports for this thread to the above */
|
|
|
199 retval = thread_set_exception_ports(thread_self, EXC_MASK_BAD_ACCESS,
|
|
|
200 exc_port_s, EXCEPTION_DEFAULT,
|
|
|
201 PPC_THREAD_STATE);
|
|
|
202 if(retval != KERN_SUCCESS)
|
|
|
203 {
|
|
|
204 fprintf (stderr, "Couldn't set exception ports: %s\n",
|
|
|
205 mach_error_string (retval));
|
|
|
206 ABORT ();
|
|
|
207 }
|
|
|
208
|
|
|
209 /* set up the subthread */
|
|
|
210 retval = thread_create(task_self, &exc_thread);
|
|
|
211 if(retval != KERN_SUCCESS)
|
|
|
212 {
|
|
|
213 fprintf (stderr , "Couldn't create exception thread: %s\n",
|
|
|
214 mach_error_string (retval));
|
|
|
215 ABORT ();
|
|
|
216 }
|
|
|
217 subthread_stack = (void *) malloc (page_size);
|
|
|
218 subthread_stack =
|
|
|
219 (char *) subthread_stack + (page_size - C_ARGSAVE_LEN - C_RED_ZONE);
|
|
|
220 exc_thread_state =
|
|
|
221 (ppc_thread_state_t *) malloc (sizeof (ppc_thread_state_t));
|
|
|
222 exc_thread_state->srr0 = (unsigned int) exception_thread;
|
|
|
223 exc_thread_state->r1 = (unsigned int) subthread_stack;
|
|
|
224 retval = thread_set_state (exc_thread, PPC_THREAD_STATE,
|
|
|
225 (thread_state_t) exc_thread_state,
|
|
|
226 PPC_THREAD_STATE_COUNT);
|
|
|
227 if (retval != KERN_SUCCESS)
|
|
|
228 {
|
|
|
229 fprintf (stderr, "Couldn't set subthread state: %s\n",
|
|
|
230 mach_error_string (retval));
|
|
|
231 ABORT ();
|
|
|
232 }
|
|
|
233 retval = thread_resume (exc_thread);
|
|
|
234 if (retval != KERN_SUCCESS)
|
|
|
235 {
|
|
|
236 fprintf (stderr, "Couldn't resume subthread: %s\n",
|
|
|
237 mach_error_string (retval));
|
|
|
238 ABORT ();
|
|
|
239 }
|
|
|
240 allow_incremental_gc = 1;
|
|
|
241 }
|
|
|
242
|
|
|
243 void
|
|
|
244 vdb_protect (void *ptr, EMACS_INT len)
|
|
|
245 {
|
|
|
246 if (mprotect (ptr, len, PROT_READ))
|
|
|
247 {
|
|
|
248 perror ("Couldn't mprotect");
|
|
|
249 ABORT ();
|
|
|
250 }
|
|
|
251 }
|
|
|
252
|
|
|
253 void
|
|
|
254 vdb_unprotect (void *ptr, EMACS_INT len)
|
|
|
255 {
|
|
|
256 if (mprotect (ptr, len, PROT_READ | PROT_WRITE))
|
|
|
257 {
|
|
|
258 perror ("Couldn't mprotect");
|
|
|
259 ABORT ();
|
|
|
260 }
|
|
|
261 }
|
