Mercurial > hg > xemacs-beta

comparison src/vdb-mach.c @ 3092:141c2920ea48

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[xemacs-hg @ 2005-11-25 01:41:31 by crestani] Incremental Garbage Collector
author crestani
date Fri, 25 Nov 2005 01:42:08 +0000
parents
children 308d34e9f07d
comparison
equal deleted inserted replaced
3091:c22d8984148c 3092:141c2920ea48
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 }