1 /*
2 * Server-side debugger support using Mach primitives
3 *
4 * Copyright (C) 1999, 2006 Alexandre Julliard
5 * Copyright (C) 2006 Ken Thomases for CodeWeavers
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <errno.h>
27 #include <stdio.h>
28 #include <signal.h>
29 #include <stdarg.h>
30 #include <sys/types.h>
31 #include <unistd.h>
32
33 #include "ntstatus.h"
34 #define WIN32_NO_STATUS
35 #include "winternl.h"
36
37 #include "file.h"
38 #include "process.h"
39 #include "thread.h"
40 #include "request.h"
41 #include "wine/library.h"
42
43 #ifdef USE_MACH
44
45 #include <mach/mach.h>
46 #include <mach/mach_error.h>
47 #include <mach/thread_act.h>
48 #include <servers/bootstrap.h>
49
50 #if defined(__APPLE__) && defined(__i386__)
51 extern int pthread_kill_syscall( mach_port_t, int );
52 __ASM_GLOBAL_FUNC( pthread_kill_syscall,
53 "movl $328,%eax\n\t" /* SYS___pthread_kill */
54 "int $0x80\n\t"
55 "jae 1f\n\t"
56 "negl %eax\n"
57 "1:\tret" )
58 #else
59 static inline int pthread_kill_syscall( mach_port_t, int )
60 {
61 return -ENOSYS;
62 }
63 #endif
64
65 static mach_port_t server_mach_port;
66
67 void sigchld_callback(void)
68 {
69 assert(0); /* should never be called on MacOS */
70 }
71
72 static void mach_set_error(kern_return_t mach_error)
73 {
74 switch (mach_error)
75 {
76 case KERN_SUCCESS: break;
77 case KERN_INVALID_ARGUMENT: set_error(STATUS_INVALID_PARAMETER); break;
78 case KERN_NO_SPACE: set_error(STATUS_NO_MEMORY); break;
79 case KERN_PROTECTION_FAILURE: set_error(STATUS_ACCESS_DENIED); break;
80 case KERN_INVALID_ADDRESS: set_error(STATUS_ACCESS_VIOLATION); break;
81 default: set_error(STATUS_UNSUCCESSFUL); break;
82 }
83 }
84
85 static mach_port_t get_process_port( struct process *process )
86 {
87 return process->trace_data;
88 }
89
90 /* initialize the process control mechanism */
91 void init_tracing_mechanism(void)
92 {
93 mach_port_t bp;
94
95 if (task_get_bootstrap_port(mach_task_self(), &bp) != KERN_SUCCESS)
96 fatal_error("Can't find bootstrap port\n");
97 if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &server_mach_port) != KERN_SUCCESS)
98 fatal_error("Can't allocate port\n");
99 if (mach_port_insert_right( mach_task_self(),
100 server_mach_port,
101 server_mach_port,
102 MACH_MSG_TYPE_MAKE_SEND ) != KERN_SUCCESS)
103 fatal_error("Error inserting rights\n");
104 if (bootstrap_register(bp, (char*)wine_get_server_dir(), server_mach_port) != KERN_SUCCESS)
105 fatal_error("Can't check in server_mach_port\n");
106 mach_port_deallocate(mach_task_self(), bp);
107 }
108
109 /* initialize the per-process tracing mechanism */
110 void init_process_tracing( struct process *process )
111 {
112 int pid, ret;
113 struct
114 {
115 mach_msg_header_t header;
116 mach_msg_body_t body;
117 mach_msg_port_descriptor_t task_port;
118 mach_msg_trailer_t trailer; /* only present on receive */
119 } msg;
120
121 for (;;)
122 {
123 ret = mach_msg( &msg.header, MACH_RCV_MSG|MACH_RCV_TIMEOUT, 0, sizeof(msg),
124 server_mach_port, 0, 0 );
125 if (ret)
126 {
127 if (ret != MACH_RCV_TIMED_OUT && debug_level)
128 fprintf( stderr, "warning: mach port receive failed with %x\n", ret );
129 return;
130 }
131
132 /* if anything in the message is invalid, ignore it */
133 if (msg.header.msgh_size != offsetof(typeof(msg), trailer)) continue;
134 if (msg.body.msgh_descriptor_count != 1) continue;
135 if (msg.task_port.type != MACH_MSG_PORT_DESCRIPTOR) continue;
136 if (msg.task_port.disposition != MACH_MSG_TYPE_PORT_SEND) continue;
137 if (msg.task_port.name == MACH_PORT_NULL) continue;
138 if (msg.task_port.name == MACH_PORT_DEAD) continue;
139
140 if (!pid_for_task( msg.task_port.name, &pid ))
141 {
142 struct thread *thread = get_thread_from_pid( pid );
143
144 if (thread && !thread->process->trace_data)
145 thread->process->trace_data = msg.task_port.name;
146 else
147 mach_port_deallocate( mach_task_self(), msg.task_port.name );
148 }
149 }
150 }
151
152 /* terminate the per-process tracing mechanism */
153 void finish_process_tracing( struct process *process )
154 {
155 if (process->trace_data)
156 {
157 mach_port_deallocate( mach_task_self(), process->trace_data );
158 process->trace_data = 0;
159 }
160 }
161
162 /* retrieve the thread x86 registers */
163 void get_thread_context( struct thread *thread, CONTEXT *context, unsigned int flags )
164 {
165 #ifdef __i386__
166 x86_debug_state32_t state;
167 mach_msg_type_number_t count = sizeof(state) / sizeof(int);
168 mach_msg_type_name_t type;
169 mach_port_t port, process_port = get_process_port( thread->process );
170
171 /* all other regs are handled on the client side */
172 assert( (flags | CONTEXT_i386) == CONTEXT_DEBUG_REGISTERS );
173
174 if (thread->unix_pid == -1 || !process_port ||
175 mach_port_extract_right( process_port, thread->unix_tid,
176 MACH_MSG_TYPE_COPY_SEND, &port, &type ))
177 {
178 set_error( STATUS_ACCESS_DENIED );
179 return;
180 }
181
182 if (!thread_get_state( port, x86_DEBUG_STATE32, (thread_state_t)&state, &count ))
183 {
184 /* work around silly renaming of struct members in OS X 10.5 */
185 #if __DARWIN_UNIX03 && defined(_STRUCT_X86_DEBUG_STATE32)
186 context->Dr0 = state.__dr0;
187 context->Dr1 = state.__dr1;
188 context->Dr2 = state.__dr2;
189 context->Dr3 = state.__dr3;
190 context->Dr6 = state.__dr6;
191 context->Dr7 = state.__dr7;
192 #else
193 context->Dr0 = state.dr0;
194 context->Dr1 = state.dr1;
195 context->Dr2 = state.dr2;
196 context->Dr3 = state.dr3;
197 context->Dr6 = state.dr6;
198 context->Dr7 = state.dr7;
199 #endif
200 context->ContextFlags |= CONTEXT_DEBUG_REGISTERS;
201 }
202 mach_port_deallocate( mach_task_self(), port );
203 #endif
204 }
205
206 /* set the thread x86 registers */
207 void set_thread_context( struct thread *thread, const CONTEXT *context, unsigned int flags )
208 {
209 #ifdef __i386__
210 x86_debug_state32_t state;
211 mach_msg_type_number_t count = sizeof(state) / sizeof(int);
212 mach_msg_type_name_t type;
213 mach_port_t port, process_port = get_process_port( thread->process );
214
215 /* all other regs are handled on the client side */
216 assert( (flags | CONTEXT_i386) == CONTEXT_DEBUG_REGISTERS );
217
218 if (thread->unix_pid == -1 || !process_port ||
219 mach_port_extract_right( process_port, thread->unix_tid,
220 MACH_MSG_TYPE_COPY_SEND, &port, &type ))
221 {
222 set_error( STATUS_ACCESS_DENIED );
223 return;
224 }
225
226 #if __DARWIN_UNIX03 && defined(_STRUCT_X86_DEBUG_STATE32)
227 state.__dr0 = context->Dr0;
228 state.__dr1 = context->Dr1;
229 state.__dr2 = context->Dr2;
230 state.__dr3 = context->Dr3;
231 state.__dr4 = 0;
232 state.__dr5 = 0;
233 state.__dr6 = context->Dr6;
234 state.__dr7 = context->Dr7;
235 #else
236 state.dr0 = context->Dr0;
237 state.dr1 = context->Dr1;
238 state.dr2 = context->Dr2;
239 state.dr3 = context->Dr3;
240 state.dr4 = 0;
241 state.dr5 = 0;
242 state.dr6 = context->Dr6;
243 state.dr7 = context->Dr7;
244 #endif
245 if (!thread_set_state( port, x86_DEBUG_STATE32, (thread_state_t)&state, count ))
246 {
247 if (thread->context) /* update the cached values */
248 {
249 thread->context->Dr0 = context->Dr0;
250 thread->context->Dr1 = context->Dr1;
251 thread->context->Dr2 = context->Dr2;
252 thread->context->Dr3 = context->Dr3;
253 thread->context->Dr6 = context->Dr6;
254 thread->context->Dr7 = context->Dr7;
255 }
256 }
257 mach_port_deallocate( mach_task_self(), port );
258 #endif
259 }
260
261 int send_thread_signal( struct thread *thread, int sig )
262 {
263 int ret = -1;
264 mach_port_t process_port = get_process_port( thread->process );
265
266 if (thread->unix_pid != -1 && process_port)
267 {
268 mach_msg_type_name_t type;
269 mach_port_t port;
270
271 if (!mach_port_extract_right( process_port, thread->unix_tid,
272 MACH_MSG_TYPE_COPY_SEND, &port, &type ))
273 {
274 if ((ret = pthread_kill_syscall( port, sig )) < 0)
275 {
276 errno = -ret;
277 ret = -1;
278 }
279 mach_port_deallocate( mach_task_self(), port );
280 }
281 else errno = ESRCH;
282
283 if (ret == -1 && errno == ESRCH) /* thread got killed */
284 {
285 thread->unix_pid = -1;
286 thread->unix_tid = -1;
287 }
288 }
289 if (debug_level && ret != -1)
290 fprintf( stderr, "%04x: *sent signal* signal=%d\n", thread->id, sig );
291 return (ret != -1);
292 }
293
294 /* read data from a process memory space */
295 int read_process_memory( struct process *process, client_ptr_t ptr, data_size_t size, char *dest )
296 {
297 kern_return_t ret;
298 mach_msg_type_number_t bytes_read;
299 vm_offset_t offset, data;
300 vm_address_t aligned_address;
301 vm_size_t aligned_size;
302 unsigned int page_size = get_page_size();
303 mach_port_t process_port = get_process_port( process );
304
305 if (!process_port)
306 {
307 set_error( STATUS_ACCESS_DENIED );
308 return 0;
309 }
310 if ((vm_address_t)ptr != ptr)
311 {
312 set_error( STATUS_ACCESS_DENIED );
313 return 0;
314 }
315
316 if ((ret = task_suspend( process_port )) != KERN_SUCCESS)
317 {
318 mach_set_error( ret );
319 return 0;
320 }
321
322 offset = ptr % page_size;
323 aligned_address = (vm_address_t)(ptr - offset);
324 aligned_size = (size + offset + page_size - 1) / page_size * page_size;
325
326 ret = vm_read( process_port, aligned_address, aligned_size, &data, &bytes_read );
327 if (ret != KERN_SUCCESS) mach_set_error( ret );
328 else
329 {
330 memcpy( dest, (char *)data + offset, size );
331 vm_deallocate( mach_task_self(), data, bytes_read );
332 }
333 task_resume( process_port );
334 return (ret == KERN_SUCCESS);
335 }
336
337 /* write data to a process memory space */
338 int write_process_memory( struct process *process, client_ptr_t ptr, data_size_t size, const char *src )
339 {
340 kern_return_t ret;
341 vm_address_t aligned_address, region_address;
342 vm_size_t aligned_size, region_size;
343 mach_msg_type_number_t info_size, bytes_read;
344 vm_offset_t offset, task_mem = 0;
345 struct vm_region_basic_info info;
346 mach_port_t dummy;
347 unsigned int page_size = get_page_size();
348 mach_port_t process_port = get_process_port( process );
349
350 if (!process_port)
351 {
352 set_error( STATUS_ACCESS_DENIED );
353 return 0;
354 }
355 if ((vm_address_t)ptr != ptr)
356 {
357 set_error( STATUS_ACCESS_DENIED );
358 return 0;
359 }
360
361 offset = ptr % page_size;
362 aligned_address = (vm_address_t)(ptr - offset);
363 aligned_size = (size + offset + page_size - 1) / page_size * page_size;
364
365 if ((ret = task_suspend( process_port )) != KERN_SUCCESS)
366 {
367 mach_set_error( ret );
368 return 0;
369 }
370
371 ret = vm_read( process_port, aligned_address, aligned_size, &task_mem, &bytes_read );
372 if (ret != KERN_SUCCESS)
373 {
374 mach_set_error( ret );
375 goto failed;
376 }
377 region_address = aligned_address;
378 info_size = sizeof(info);
379 ret = vm_region( process_port, ®ion_address, ®ion_size, VM_REGION_BASIC_INFO,
380 (vm_region_info_t)&info, &info_size, &dummy );
381 if (ret != KERN_SUCCESS)
382 {
383 mach_set_error( ret );
384 goto failed;
385 }
386 if (region_address > aligned_address ||
387 region_address + region_size < aligned_address + aligned_size)
388 {
389 /* FIXME: should support multiple regions */
390 set_error( ERROR_ACCESS_DENIED );
391 goto failed;
392 }
393 ret = vm_protect( process_port, aligned_address, aligned_size, 0, VM_PROT_READ | VM_PROT_WRITE );
394 if (ret != KERN_SUCCESS)
395 {
396 mach_set_error( ret );
397 goto failed;
398 }
399
400 /* FIXME: there's an optimization that can be made: check first and last */
401 /* pages for writability; read first and last pages; write interior */
402 /* pages to task without ever reading&modifying them; if that succeeds, */
403 /* modify first and last pages and write them. */
404
405 memcpy( (char*)task_mem + offset, src, size );
406
407 ret = vm_write( process_port, aligned_address, task_mem, bytes_read );
408 if (ret != KERN_SUCCESS) mach_set_error( ret );
409 else
410 {
411 vm_deallocate( mach_task_self(), task_mem, bytes_read );
412 /* restore protection */
413 vm_protect( process_port, aligned_address, aligned_size, 0, info.protection );
414 task_resume( process_port );
415 return 1;
416 }
417
418 failed:
419 if (task_mem) vm_deallocate( mach_task_self(), task_mem, bytes_read );
420 task_resume( process_port );
421 return 0;
422 }
423
424 /* retrieve an LDT selector entry */
425 void get_selector_entry( struct thread *thread, int entry, unsigned int *base,
426 unsigned int *limit, unsigned char *flags )
427 {
428 const unsigned int total_size = (2 * sizeof(int) + 1) * 8192;
429 struct process *process = thread->process;
430 unsigned int page_size = get_page_size();
431 vm_offset_t data;
432 kern_return_t ret;
433 mach_msg_type_number_t bytes_read;
434 mach_port_t process_port = get_process_port( thread->process );
435
436 if (!process->ldt_copy || !process_port)
437 {
438 set_error( STATUS_ACCESS_DENIED );
439 return;
440 }
441 if (entry >= 8192)
442 {
443 set_error( STATUS_INVALID_PARAMETER ); /* FIXME */
444 return;
445 }
446
447 if ((ret = task_suspend( process_port )) == KERN_SUCCESS)
448 {
449 vm_offset_t offset = process->ldt_copy % page_size;
450 vm_address_t aligned_address = (vm_address_t)(process->ldt_copy - offset);
451 vm_size_t aligned_size = (total_size + offset + page_size - 1) / page_size * page_size;
452
453 ret = vm_read( process_port, aligned_address, aligned_size, &data, &bytes_read );
454 if (ret != KERN_SUCCESS) mach_set_error( ret );
455 else
456 {
457 const int *ldt = (const int *)((char *)data + offset);
458 memcpy( base, ldt + entry, sizeof(int) );
459 memcpy( limit, ldt + entry + 8192, sizeof(int) );
460 memcpy( flags, (char *)(ldt + 2 * 8192) + entry, 1 );
461 vm_deallocate( mach_task_self(), data, bytes_read );
462 }
463 task_resume( process_port );
464 }
465 else mach_set_error( ret );
466 }
467
468 #endif /* USE_MACH */
469
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.