/* * Server-side debugger support using Mach primitives * * Copyright (C) 1999, 2006 Alexandre Julliard * Copyright (C) 2006 Ken Thomases for CodeWeavers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" #include "wine/port.h" #include <assert.h> #include <errno.h> #include <stdio.h> #include <signal.h> #include <stdarg.h> #include <sys/types.h> #include <unistd.h> #include "ntstatus.h" #define WIN32_NO_STATUS #include "winternl.h" #include "file.h" #include "process.h" #include "thread.h" #include "request.h" #include "wine/library.h" #ifdef USE_MACH #include <mach/mach.h> #include <mach/mach_error.h> #include <mach/thread_act.h> #include <servers/bootstrap.h> #if defined(__APPLE__) && defined(__i386__) extern int pthread_kill_syscall( mach_port_t, int ); __ASM_GLOBAL_FUNC( pthread_kill_syscall, "movl $328,%eax\n\t" /* SYS___pthread_kill */ "int $0x80\n\t" "jae 1f\n\t" "negl %eax\n" "1:\tret" ); #else static inline int pthread_kill_syscall( mach_port_t, int ) { return -ENOSYS; } #endif static mach_port_t server_mach_port; void sigchld_callback(void) { assert(0); /* should never be called on MacOS */ } static void mach_set_error(kern_return_t mach_error) { switch (mach_error) { case KERN_SUCCESS: break; case KERN_INVALID_ARGUMENT: set_error(STATUS_INVALID_PARAMETER); break; case KERN_NO_SPACE: set_error(STATUS_NO_MEMORY); break; case KERN_PROTECTION_FAILURE: set_error(STATUS_ACCESS_DENIED); break; case KERN_INVALID_ADDRESS: set_error(STATUS_ACCESS_VIOLATION); break; default: set_error(STATUS_UNSUCCESSFUL); break; } } static mach_port_t get_process_port( struct process *process ) { return process->trace_data; } /* initialize the process control mechanism */ void init_tracing_mechanism(void) { mach_port_t bp; if (task_get_bootstrap_port(mach_task_self(), &bp) != KERN_SUCCESS) fatal_error("Can't find bootstrap port\n"); if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &server_mach_port) != KERN_SUCCESS) fatal_error("Can't allocate port\n"); if (mach_port_insert_right( mach_task_self(), server_mach_port, server_mach_port, MACH_MSG_TYPE_MAKE_SEND ) != KERN_SUCCESS) fatal_error("Error inserting rights\n"); if (bootstrap_register(bp, (char*)wine_get_server_dir(), server_mach_port) != KERN_SUCCESS) fatal_error("Can't check in server_mach_port\n"); mach_port_deallocate(mach_task_self(), bp); } /* initialize the per-process tracing mechanism */ void init_process_tracing( struct process *process ) { int pid, ret; struct { mach_msg_header_t header; mach_msg_body_t body; mach_msg_port_descriptor_t task_port; mach_msg_trailer_t trailer; /* only present on receive */ } msg; for (;;) { ret = mach_msg( &msg.header, MACH_RCV_MSG|MACH_RCV_TIMEOUT, 0, sizeof(msg), server_mach_port, 0, 0 ); if (ret) { if (ret != MACH_RCV_TIMED_OUT && debug_level) fprintf( stderr, "warning: mach port receive failed with %x\n", ret ); return; } /* if anything in the message is invalid, ignore it */ if (msg.header.msgh_size != offsetof(typeof(msg), trailer)) continue; if (msg.body.msgh_descriptor_count != 1) continue; if (msg.task_port.type != MACH_MSG_PORT_DESCRIPTOR) continue; if (msg.task_port.disposition != MACH_MSG_TYPE_PORT_SEND) continue; if (msg.task_port.name == MACH_PORT_NULL) continue; if (msg.task_port.name == MACH_PORT_DEAD) continue; if (!pid_for_task( msg.task_port.name, &pid )) { struct thread *thread = get_thread_from_pid( pid ); if (thread && !thread->process->trace_data) thread->process->trace_data = msg.task_port.name; else mach_port_deallocate( mach_task_self(), msg.task_port.name ); } } } /* terminate the per-process tracing mechanism */ void finish_process_tracing( struct process *process ) { if (process->trace_data) { mach_port_deallocate( mach_task_self(), process->trace_data ); process->trace_data = 0; } } /* retrieve the thread x86 registers */ void get_thread_context( struct thread *thread, CONTEXT *context, unsigned int flags ) { #ifdef __i386__ x86_debug_state32_t state; mach_msg_type_number_t count = sizeof(state) / sizeof(int); mach_msg_type_name_t type; mach_port_t port, process_port = get_process_port( thread->process ); /* all other regs are handled on the client side */ assert( (flags | CONTEXT_i386) == CONTEXT_DEBUG_REGISTERS ); if (thread->unix_pid == -1 || !process_port || mach_port_extract_right( process_port, thread->unix_tid, MACH_MSG_TYPE_COPY_SEND, &port, &type )) { set_error( STATUS_ACCESS_DENIED ); return; } if (!thread_get_state( port, x86_DEBUG_STATE32, (thread_state_t)&state, &count )) { /* work around silly renaming of struct members in OS X 10.5 */ #if __DARWIN_UNIX03 && defined(_STRUCT_X86_DEBUG_STATE32) context->Dr0 = state.__dr0; context->Dr1 = state.__dr1; context->Dr2 = state.__dr2; context->Dr3 = state.__dr3; context->Dr6 = state.__dr6; context->Dr7 = state.__dr7; #else context->Dr0 = state.dr0; context->Dr1 = state.dr1; context->Dr2 = state.dr2; context->Dr3 = state.dr3; context->Dr6 = state.dr6; context->Dr7 = state.dr7; #endif context->ContextFlags |= CONTEXT_DEBUG_REGISTERS; } mach_port_deallocate( mach_task_self(), port ); #endif } /* set the thread x86 registers */ void set_thread_context( struct thread *thread, const CONTEXT *context, unsigned int flags ) { #ifdef __i386__ x86_debug_state32_t state; mach_msg_type_number_t count = sizeof(state) / sizeof(int); mach_msg_type_name_t type; mach_port_t port, process_port = get_process_port( thread->process ); /* all other regs are handled on the client side */ assert( (flags | CONTEXT_i386) == CONTEXT_DEBUG_REGISTERS ); if (thread->unix_pid == -1 || !process_port || mach_port_extract_right( process_port, thread->unix_tid, MACH_MSG_TYPE_COPY_SEND, &port, &type )) { set_error( STATUS_ACCESS_DENIED ); return; } #if __DARWIN_UNIX03 && defined(_STRUCT_X86_DEBUG_STATE32) state.__dr0 = context->Dr0; state.__dr1 = context->Dr1; state.__dr2 = context->Dr2; state.__dr3 = context->Dr3; state.__dr4 = 0; state.__dr5 = 0; state.__dr6 = context->Dr6; state.__dr7 = context->Dr7; #else state.dr0 = context->Dr0; state.dr1 = context->Dr1; state.dr2 = context->Dr2; state.dr3 = context->Dr3; state.dr4 = 0; state.dr5 = 0; state.dr6 = context->Dr6; state.dr7 = context->Dr7; #endif if (!thread_set_state( port, x86_DEBUG_STATE32, (thread_state_t)&state, count )) { if (thread->context) /* update the cached values */ { thread->context->Dr0 = context->Dr0; thread->context->Dr1 = context->Dr1; thread->context->Dr2 = context->Dr2; thread->context->Dr3 = context->Dr3; thread->context->Dr6 = context->Dr6; thread->context->Dr7 = context->Dr7; } } mach_port_deallocate( mach_task_self(), port ); #endif } int send_thread_signal( struct thread *thread, int sig ) { int ret = -1; mach_port_t process_port = get_process_port( thread->process ); if (thread->unix_pid != -1 && process_port) { mach_msg_type_name_t type; mach_port_t port; if (!mach_port_extract_right( process_port, thread->unix_tid, MACH_MSG_TYPE_COPY_SEND, &port, &type )) { if ((ret = pthread_kill_syscall( port, sig )) < 0) { errno = -ret; ret = -1; } mach_port_deallocate( mach_task_self(), port ); } else errno = ESRCH; if (ret == -1 && errno == ESRCH) /* thread got killed */ { thread->unix_pid = -1; thread->unix_tid = -1; } } if (debug_level && ret != -1) fprintf( stderr, "%04x: *sent signal* signal=%d\n", thread->id, sig ); return (ret != -1); } /* read data from a process memory space */ int read_process_memory( struct process *process, const void *ptr, data_size_t size, char *dest ) { kern_return_t ret; mach_msg_type_number_t bytes_read; vm_offset_t offset, data; vm_address_t aligned_address; vm_size_t aligned_size; unsigned int page_size = get_page_size(); mach_port_t process_port = get_process_port( process ); if (!process_port) { set_error( STATUS_ACCESS_DENIED ); return 0; } if ((ret = task_suspend( process_port )) != KERN_SUCCESS) { mach_set_error( ret ); return 0; } offset = (unsigned long)ptr % page_size; aligned_address = (vm_address_t)((char *)ptr - offset); aligned_size = (size + offset + page_size - 1) / page_size * page_size; ret = vm_read( process_port, aligned_address, aligned_size, &data, &bytes_read ); if (ret != KERN_SUCCESS) mach_set_error( ret ); else { memcpy( dest, (char *)data + offset, size ); vm_deallocate( mach_task_self(), data, bytes_read ); } task_resume( process_port ); return (ret == KERN_SUCCESS); } /* write data to a process memory space */ int write_process_memory( struct process *process, void *ptr, data_size_t size, const char *src ) { kern_return_t ret; vm_address_t aligned_address, region_address; vm_size_t aligned_size, region_size; mach_msg_type_number_t info_size, bytes_read; vm_offset_t offset, task_mem = 0; struct vm_region_basic_info info; mach_port_t dummy; unsigned int page_size = get_page_size(); mach_port_t process_port = get_process_port( process ); if (!process_port) { set_error( STATUS_ACCESS_DENIED ); return 0; } offset = (unsigned long)ptr % page_size; aligned_address = (vm_address_t)((char *)ptr - offset); aligned_size = (size + offset + page_size - 1) / page_size * page_size; if ((ret = task_suspend( process_port )) != KERN_SUCCESS) { mach_set_error( ret ); return 0; } ret = vm_read( process_port, aligned_address, aligned_size, &task_mem, &bytes_read ); if (ret != KERN_SUCCESS) { mach_set_error( ret ); goto failed; } region_address = aligned_address; info_size = sizeof(info); ret = vm_region( process_port, ®ion_address, ®ion_size, VM_REGION_BASIC_INFO, (vm_region_info_t)&info, &info_size, &dummy ); if (ret != KERN_SUCCESS) { mach_set_error( ret ); goto failed; } if (region_address > aligned_address || region_address + region_size < aligned_address + aligned_size) { /* FIXME: should support multiple regions */ set_error( ERROR_ACCESS_DENIED ); goto failed; } ret = vm_protect( process_port, aligned_address, aligned_size, 0, VM_PROT_READ | VM_PROT_WRITE ); if (ret != KERN_SUCCESS) { mach_set_error( ret ); goto failed; } /* FIXME: there's an optimization that can be made: check first and last */ /* pages for writability; read first and last pages; write interior */ /* pages to task without ever reading&modifying them; if that succeeds, */ /* modify first and last pages and write them. */ memcpy( (char*)task_mem + offset, src, size ); ret = vm_write( process_port, aligned_address, task_mem, bytes_read ); if (ret != KERN_SUCCESS) mach_set_error( ret ); else { vm_deallocate( mach_task_self(), task_mem, bytes_read ); /* restore protection */ vm_protect( process_port, aligned_address, aligned_size, 0, info.protection ); task_resume( process_port ); return 1; } failed: if (task_mem) vm_deallocate( mach_task_self(), task_mem, bytes_read ); task_resume( process_port ); return 0; } /* retrieve an LDT selector entry */ void get_selector_entry( struct thread *thread, int entry, unsigned int *base, unsigned int *limit, unsigned char *flags ) { const unsigned int total_size = (2 * sizeof(int) + 1) * 8192; struct process *process = thread->process; unsigned int page_size = get_page_size(); vm_offset_t data; kern_return_t ret; mach_msg_type_number_t bytes_read; mach_port_t process_port = get_process_port( thread->process ); if (!process->ldt_copy || !process_port) { set_error( STATUS_ACCESS_DENIED ); return; } if (entry >= 8192) { set_error( STATUS_INVALID_PARAMETER ); /* FIXME */ return; } if ((ret = task_suspend( process_port )) == KERN_SUCCESS) { void *ptr = process->ldt_copy; vm_offset_t offset = (unsigned long)ptr % page_size; vm_address_t aligned_address = (vm_address_t)((char *)ptr - offset); vm_size_t aligned_size = (total_size + offset + page_size - 1) / page_size * page_size; ret = vm_read( process_port, aligned_address, aligned_size, &data, &bytes_read ); if (ret != KERN_SUCCESS) mach_set_error( ret ); else { const int *ldt = (const int *)((char *)data + offset); memcpy( base, ldt + entry, sizeof(int) ); memcpy( limit, ldt + entry + 8192, sizeof(int) ); memcpy( flags, (char *)(ldt + 2 * 8192) + entry, 1 ); vm_deallocate( mach_task_self(), data, bytes_read ); } task_resume( process_port ); } else mach_set_error( ret ); } #endif /* USE_MACH */