| /* |
| * A Win32 based proxy implementing the GBD remote protocol |
| * This allows to debug Wine (and any "emulated" program) under |
| * Linux using GDB |
| * |
| * Copyright (c) Eric Pouech 2002-2004 |
| * |
| * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| /* Protocol specification can be found here: |
| * http://sources.redhat.com/gdb/onlinedocs/gdb_32.html |
| */ |
| |
| #include "config.h" |
| #include "wine/port.h" |
| |
| #include <assert.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <signal.h> |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <sys/poll.h> |
| #include <sys/wait.h> |
| #ifdef HAVE_SYS_SOCKET_H |
| # include <sys/socket.h> |
| #endif |
| #include <netinet/in.h> |
| #include <netinet/tcp.h> |
| #ifdef HAVE_UNISTD_H |
| # include <unistd.h> |
| #endif |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "tlhelp32.h" |
| |
| /* those two are needed only for the SHOWNORMAL flag */ |
| #include "wingdi.h" |
| #include "winuser.h" |
| |
| #include "debugger.h" |
| |
| #define GDBPXY_TRC_LOWLEVEL 0x01 |
| #define GDBPXY_TRC_PACKET 0x02 |
| #define GDBPXY_TRC_COMMAND 0x04 |
| #define GDBPXY_TRC_COMMAND_ERROR 0x08 |
| #define GDBPXY_TRC_WIN32_EVENT 0x10 |
| #define GDBPXY_TRC_WIN32_ERROR 0x20 |
| #define GDBPXY_TRC_COMMAND_FIXME 0x80 |
| |
| struct gdb_ctx_Xpoint |
| { |
| enum be_xpoint_type type; /* -1 means free */ |
| void* addr; |
| unsigned long val; |
| }; |
| |
| struct gdb_context |
| { |
| /* gdb information */ |
| int sock; |
| /* incoming buffer */ |
| char* in_buf; |
| int in_buf_alloc; |
| int in_len; |
| /* split into individual packet */ |
| char* in_packet; |
| int in_packet_len; |
| /* outgoing buffer */ |
| char* out_buf; |
| int out_buf_alloc; |
| int out_len; |
| int out_curr_packet; |
| /* generic GDB thread information */ |
| struct dbg_thread* exec_thread; /* thread used in step & continue */ |
| struct dbg_thread* other_thread; /* thread to be used in any other operation */ |
| unsigned trace; |
| /* current Win32 trap env */ |
| unsigned last_sig; |
| BOOL in_trap; |
| CONTEXT context; |
| /* Win32 information */ |
| struct dbg_process* process; |
| #define NUM_XPOINT 32 |
| struct gdb_ctx_Xpoint Xpoints[NUM_XPOINT]; |
| /* Unix environment */ |
| unsigned long wine_segs[3]; /* load addresses of the ELF wine exec segments (text, bss and data) */ |
| }; |
| |
| /* =============================================== * |
| * B A S I C M A N I P U L A T I O N S * |
| * =============================================== * |
| */ |
| |
| static inline int hex_from0(char ch) |
| { |
| if (ch >= '0' && ch <= '9') return ch - '0'; |
| if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10; |
| if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10; |
| |
| assert(0); |
| return 0; |
| } |
| |
| static inline unsigned char hex_to0(int x) |
| { |
| assert(x >= 0 && x < 16); |
| return "0123456789abcdef"[x]; |
| } |
| |
| static int hex_to_int(const char* src, size_t len){ |
| unsigned int returnval = 0; |
| while (len--){ |
| returnval=hex_from0(src[0]); |
| if(len) returnval<<=4; |
| } |
| return returnval; |
| } |
| |
| static void hex_from(void* dst, const char* src, size_t len) |
| { |
| unsigned char *p = dst; |
| while (len--) |
| { |
| *p++ = (hex_from0(src[0]) << 4) | hex_from0(src[1]); |
| src += 2; |
| } |
| } |
| |
| static void hex_to(char* dst, const void* src, size_t len) |
| { |
| const unsigned char *p = src; |
| while (len--) |
| { |
| *dst++ = hex_to0(*p >> 4); |
| *dst++ = hex_to0(*p & 0x0F); |
| p++; |
| } |
| } |
| |
| static unsigned char checksum(const char* ptr, int len) |
| { |
| unsigned cksum = 0; |
| |
| while (len-- > 0) |
| cksum += (unsigned char)*ptr++; |
| return cksum; |
| } |
| |
| /* =============================================== * |
| * C P U H A N D L E R S * |
| * =============================================== * |
| */ |
| |
| #ifdef __i386__ |
| static size_t cpu_register_map[] = { |
| FIELD_OFFSET(CONTEXT, Eax), |
| FIELD_OFFSET(CONTEXT, Ecx), |
| FIELD_OFFSET(CONTEXT, Edx), |
| FIELD_OFFSET(CONTEXT, Ebx), |
| FIELD_OFFSET(CONTEXT, Esp), |
| FIELD_OFFSET(CONTEXT, Ebp), |
| FIELD_OFFSET(CONTEXT, Esi), |
| FIELD_OFFSET(CONTEXT, Edi), |
| FIELD_OFFSET(CONTEXT, Eip), |
| FIELD_OFFSET(CONTEXT, EFlags), |
| FIELD_OFFSET(CONTEXT, SegCs), |
| FIELD_OFFSET(CONTEXT, SegSs), |
| FIELD_OFFSET(CONTEXT, SegDs), |
| FIELD_OFFSET(CONTEXT, SegEs), |
| FIELD_OFFSET(CONTEXT, SegFs), |
| FIELD_OFFSET(CONTEXT, SegGs), |
| }; |
| #elif defined(__powerpc__) |
| static size_t cpu_register_map[] = { |
| FIELD_OFFSET(CONTEXT, Gpr0), |
| FIELD_OFFSET(CONTEXT, Gpr1), |
| FIELD_OFFSET(CONTEXT, Gpr2), |
| FIELD_OFFSET(CONTEXT, Gpr3), |
| FIELD_OFFSET(CONTEXT, Gpr4), |
| FIELD_OFFSET(CONTEXT, Gpr5), |
| FIELD_OFFSET(CONTEXT, Gpr6), |
| FIELD_OFFSET(CONTEXT, Gpr7), |
| FIELD_OFFSET(CONTEXT, Gpr8), |
| FIELD_OFFSET(CONTEXT, Gpr9), |
| FIELD_OFFSET(CONTEXT, Gpr10), |
| FIELD_OFFSET(CONTEXT, Gpr11), |
| FIELD_OFFSET(CONTEXT, Gpr12), |
| FIELD_OFFSET(CONTEXT, Gpr13), |
| FIELD_OFFSET(CONTEXT, Gpr14), |
| FIELD_OFFSET(CONTEXT, Gpr15), |
| FIELD_OFFSET(CONTEXT, Gpr16), |
| FIELD_OFFSET(CONTEXT, Gpr17), |
| FIELD_OFFSET(CONTEXT, Gpr18), |
| FIELD_OFFSET(CONTEXT, Gpr19), |
| FIELD_OFFSET(CONTEXT, Gpr20), |
| FIELD_OFFSET(CONTEXT, Gpr21), |
| FIELD_OFFSET(CONTEXT, Gpr22), |
| FIELD_OFFSET(CONTEXT, Gpr23), |
| FIELD_OFFSET(CONTEXT, Gpr24), |
| FIELD_OFFSET(CONTEXT, Gpr25), |
| FIELD_OFFSET(CONTEXT, Gpr26), |
| FIELD_OFFSET(CONTEXT, Gpr27), |
| FIELD_OFFSET(CONTEXT, Gpr28), |
| FIELD_OFFSET(CONTEXT, Gpr29), |
| FIELD_OFFSET(CONTEXT, Gpr30), |
| FIELD_OFFSET(CONTEXT, Gpr31), |
| FIELD_OFFSET(CONTEXT, Fpr0), |
| FIELD_OFFSET(CONTEXT, Fpr1), |
| FIELD_OFFSET(CONTEXT, Fpr2), |
| FIELD_OFFSET(CONTEXT, Fpr3), |
| FIELD_OFFSET(CONTEXT, Fpr4), |
| FIELD_OFFSET(CONTEXT, Fpr5), |
| FIELD_OFFSET(CONTEXT, Fpr6), |
| FIELD_OFFSET(CONTEXT, Fpr7), |
| FIELD_OFFSET(CONTEXT, Fpr8), |
| FIELD_OFFSET(CONTEXT, Fpr9), |
| FIELD_OFFSET(CONTEXT, Fpr10), |
| FIELD_OFFSET(CONTEXT, Fpr11), |
| FIELD_OFFSET(CONTEXT, Fpr12), |
| FIELD_OFFSET(CONTEXT, Fpr13), |
| FIELD_OFFSET(CONTEXT, Fpr14), |
| FIELD_OFFSET(CONTEXT, Fpr15), |
| FIELD_OFFSET(CONTEXT, Fpr16), |
| FIELD_OFFSET(CONTEXT, Fpr17), |
| FIELD_OFFSET(CONTEXT, Fpr18), |
| FIELD_OFFSET(CONTEXT, Fpr19), |
| FIELD_OFFSET(CONTEXT, Fpr20), |
| FIELD_OFFSET(CONTEXT, Fpr21), |
| FIELD_OFFSET(CONTEXT, Fpr22), |
| FIELD_OFFSET(CONTEXT, Fpr23), |
| FIELD_OFFSET(CONTEXT, Fpr24), |
| FIELD_OFFSET(CONTEXT, Fpr25), |
| FIELD_OFFSET(CONTEXT, Fpr26), |
| FIELD_OFFSET(CONTEXT, Fpr27), |
| FIELD_OFFSET(CONTEXT, Fpr28), |
| FIELD_OFFSET(CONTEXT, Fpr29), |
| FIELD_OFFSET(CONTEXT, Fpr30), |
| FIELD_OFFSET(CONTEXT, Fpr31), |
| |
| FIELD_OFFSET(CONTEXT, Iar), |
| FIELD_OFFSET(CONTEXT, Msr), |
| FIELD_OFFSET(CONTEXT, Cr), |
| FIELD_OFFSET(CONTEXT, Lr), |
| FIELD_OFFSET(CONTEXT, Ctr), |
| FIELD_OFFSET(CONTEXT, Xer), |
| /* FIXME: MQ is missing? FIELD_OFFSET(CONTEXT, Mq), */ |
| /* see gdb/nlm/ppc.c */ |
| }; |
| #elif defined(__ALPHA__) |
| static size_t cpu_register_map[] = { |
| FIELD_OFFSET(CONTEXT, IntV0), |
| FIELD_OFFSET(CONTEXT, IntT0), |
| FIELD_OFFSET(CONTEXT, IntT1), |
| FIELD_OFFSET(CONTEXT, IntT2), |
| FIELD_OFFSET(CONTEXT, IntT3), |
| FIELD_OFFSET(CONTEXT, IntT4), |
| FIELD_OFFSET(CONTEXT, IntT5), |
| FIELD_OFFSET(CONTEXT, IntT6), |
| FIELD_OFFSET(CONTEXT, IntT7), |
| FIELD_OFFSET(CONTEXT, IntS0), |
| FIELD_OFFSET(CONTEXT, IntS1), |
| FIELD_OFFSET(CONTEXT, IntS2), |
| FIELD_OFFSET(CONTEXT, IntS3), |
| FIELD_OFFSET(CONTEXT, IntS4), |
| FIELD_OFFSET(CONTEXT, IntS5), |
| FIELD_OFFSET(CONTEXT, IntFp), |
| FIELD_OFFSET(CONTEXT, IntA0), |
| FIELD_OFFSET(CONTEXT, IntA1), |
| FIELD_OFFSET(CONTEXT, IntA2), |
| FIELD_OFFSET(CONTEXT, IntA3), |
| FIELD_OFFSET(CONTEXT, IntA4), |
| FIELD_OFFSET(CONTEXT, IntA5), |
| FIELD_OFFSET(CONTEXT, IntT8), |
| FIELD_OFFSET(CONTEXT, IntT9), |
| FIELD_OFFSET(CONTEXT, IntT10), |
| FIELD_OFFSET(CONTEXT, IntT11), |
| FIELD_OFFSET(CONTEXT, IntRa), |
| FIELD_OFFSET(CONTEXT, IntT12), |
| FIELD_OFFSET(CONTEXT, IntAt), |
| FIELD_OFFSET(CONTEXT, IntGp), |
| FIELD_OFFSET(CONTEXT, IntSp), |
| FIELD_OFFSET(CONTEXT, IntZero), |
| FIELD_OFFSET(CONTEXT, FltF0), |
| FIELD_OFFSET(CONTEXT, FltF1), |
| FIELD_OFFSET(CONTEXT, FltF2), |
| FIELD_OFFSET(CONTEXT, FltF3), |
| FIELD_OFFSET(CONTEXT, FltF4), |
| FIELD_OFFSET(CONTEXT, FltF5), |
| FIELD_OFFSET(CONTEXT, FltF6), |
| FIELD_OFFSET(CONTEXT, FltF7), |
| FIELD_OFFSET(CONTEXT, FltF8), |
| FIELD_OFFSET(CONTEXT, FltF9), |
| FIELD_OFFSET(CONTEXT, FltF10), |
| FIELD_OFFSET(CONTEXT, FltF11), |
| FIELD_OFFSET(CONTEXT, FltF12), |
| FIELD_OFFSET(CONTEXT, FltF13), |
| FIELD_OFFSET(CONTEXT, FltF14), |
| FIELD_OFFSET(CONTEXT, FltF15), |
| FIELD_OFFSET(CONTEXT, FltF16), |
| FIELD_OFFSET(CONTEXT, FltF17), |
| FIELD_OFFSET(CONTEXT, FltF18), |
| FIELD_OFFSET(CONTEXT, FltF19), |
| FIELD_OFFSET(CONTEXT, FltF20), |
| FIELD_OFFSET(CONTEXT, FltF21), |
| FIELD_OFFSET(CONTEXT, FltF22), |
| FIELD_OFFSET(CONTEXT, FltF23), |
| FIELD_OFFSET(CONTEXT, FltF24), |
| FIELD_OFFSET(CONTEXT, FltF25), |
| FIELD_OFFSET(CONTEXT, FltF26), |
| FIELD_OFFSET(CONTEXT, FltF27), |
| FIELD_OFFSET(CONTEXT, FltF28), |
| FIELD_OFFSET(CONTEXT, FltF29), |
| FIELD_OFFSET(CONTEXT, FltF30), |
| FIELD_OFFSET(CONTEXT, FltF31), |
| |
| /* FIXME: Didn't look for the right order yet */ |
| FIELD_OFFSET(CONTEXT, Fir), |
| FIELD_OFFSET(CONTEXT, Fpcr), |
| FIELD_OFFSET(CONTEXT, SoftFpcr), |
| }; |
| #else |
| # error Define the registers map for your CPU |
| #endif |
| |
| static const size_t cpu_num_regs = (sizeof(cpu_register_map) / sizeof(cpu_register_map[0])); |
| |
| static inline unsigned long* cpu_register(CONTEXT* ctx, unsigned idx) |
| { |
| assert(idx < cpu_num_regs); |
| return (unsigned long*)((char*)ctx + cpu_register_map[idx]); |
| } |
| |
| /* =============================================== * |
| * W I N 3 2 D E B U G I N T E R F A C E * |
| * =============================================== * |
| */ |
| |
| static BOOL fetch_context(struct gdb_context* gdbctx, HANDLE h, CONTEXT* ctx) |
| { |
| ctx->ContextFlags = CONTEXT_CONTROL |
| | CONTEXT_INTEGER |
| #ifdef CONTEXT_SEGMENTS |
| | CONTEXT_SEGMENTS |
| #endif |
| #ifdef CONTEXT_DEBUG_REGISTERS |
| | CONTEXT_DEBUG_REGISTERS |
| #endif |
| ; |
| if (!GetThreadContext(h, ctx)) |
| { |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) |
| fprintf(stderr, "Can't get thread's context\n"); |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| static BOOL handle_exception(struct gdb_context* gdbctx, EXCEPTION_DEBUG_INFO* exc) |
| { |
| EXCEPTION_RECORD* rec = &exc->ExceptionRecord; |
| BOOL ret = FALSE; |
| |
| switch (rec->ExceptionCode) |
| { |
| case EXCEPTION_ACCESS_VIOLATION: |
| case EXCEPTION_PRIV_INSTRUCTION: |
| case EXCEPTION_STACK_OVERFLOW: |
| case EXCEPTION_GUARD_PAGE: |
| gdbctx->last_sig = SIGSEGV; |
| ret = TRUE; |
| break; |
| case EXCEPTION_DATATYPE_MISALIGNMENT: |
| gdbctx->last_sig = SIGBUS; |
| ret = TRUE; |
| break; |
| case EXCEPTION_SINGLE_STEP: |
| /* fall thru */ |
| case EXCEPTION_BREAKPOINT: |
| gdbctx->last_sig = SIGTRAP; |
| ret = TRUE; |
| break; |
| case EXCEPTION_FLT_DENORMAL_OPERAND: |
| case EXCEPTION_FLT_DIVIDE_BY_ZERO: |
| case EXCEPTION_FLT_INEXACT_RESULT: |
| case EXCEPTION_FLT_INVALID_OPERATION: |
| case EXCEPTION_FLT_OVERFLOW: |
| case EXCEPTION_FLT_STACK_CHECK: |
| case EXCEPTION_FLT_UNDERFLOW: |
| gdbctx->last_sig = SIGFPE; |
| ret = TRUE; |
| break; |
| case EXCEPTION_INT_DIVIDE_BY_ZERO: |
| case EXCEPTION_INT_OVERFLOW: |
| gdbctx->last_sig = SIGFPE; |
| ret = TRUE; |
| break; |
| case EXCEPTION_ILLEGAL_INSTRUCTION: |
| gdbctx->last_sig = SIGILL; |
| ret = TRUE; |
| break; |
| case CONTROL_C_EXIT: |
| gdbctx->last_sig = SIGINT; |
| ret = TRUE; |
| break; |
| case STATUS_POSSIBLE_DEADLOCK: |
| gdbctx->last_sig = SIGALRM; |
| ret = TRUE; |
| /* FIXME: we could also add here a O packet with additional information */ |
| break; |
| default: |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) |
| fprintf(stderr, "Unhandled exception code 0x%08lx\n", rec->ExceptionCode); |
| gdbctx->last_sig = SIGABRT; |
| ret = TRUE; |
| break; |
| } |
| return ret; |
| } |
| |
| static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de) |
| { |
| char buffer[256]; |
| |
| dbg_curr_thread = dbg_get_thread(gdbctx->process, de->dwThreadId); |
| |
| switch (de->dwDebugEventCode) |
| { |
| case CREATE_PROCESS_DEBUG_EVENT: |
| memory_get_string_indirect(de->u.CreateProcessInfo.hProcess, |
| de->u.CreateProcessInfo.lpImageName, |
| de->u.CreateProcessInfo.fUnicode, |
| buffer, sizeof(buffer)); |
| |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) |
| fprintf(stderr, "%08lx:%08lx: create process '%s'/%p @%08lx (%ld<%ld>)\n", |
| de->dwProcessId, de->dwThreadId, |
| buffer, de->u.CreateProcessInfo.lpImageName, |
| (unsigned long)(void*)de->u.CreateProcessInfo.lpStartAddress, |
| de->u.CreateProcessInfo.dwDebugInfoFileOffset, |
| de->u.CreateProcessInfo.nDebugInfoSize); |
| |
| gdbctx->process = dbg_add_process(de->dwProcessId, |
| de->u.CreateProcessInfo.hProcess, |
| buffer); |
| /* de->u.CreateProcessInfo.lpStartAddress; */ |
| if (!SymInitialize(gdbctx->process->handle, NULL, TRUE)) |
| fprintf(stderr, "Couldn't initiate DbgHelp\n"); |
| |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) |
| fprintf(stderr, "%08lx:%08lx: create thread I @%08lx\n", |
| de->dwProcessId, de->dwThreadId, |
| (unsigned long)(void*)de->u.CreateProcessInfo.lpStartAddress); |
| |
| assert(dbg_curr_thread == NULL); /* shouldn't be there */ |
| dbg_add_thread(gdbctx->process, de->dwThreadId, |
| de->u.CreateProcessInfo.hThread, |
| de->u.CreateProcessInfo.lpThreadLocalBase); |
| break; |
| |
| case LOAD_DLL_DEBUG_EVENT: |
| assert(dbg_curr_thread); |
| memory_get_string_indirect(gdbctx->process->handle, |
| de->u.LoadDll.lpImageName, |
| de->u.LoadDll.fUnicode, |
| buffer, sizeof(buffer)); |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) |
| fprintf(stderr, "%08lx:%08lx: loads DLL %s @%08lx (%ld<%ld>)\n", |
| de->dwProcessId, de->dwThreadId, |
| buffer, (unsigned long)de->u.LoadDll.lpBaseOfDll, |
| de->u.LoadDll.dwDebugInfoFileOffset, |
| de->u.LoadDll.nDebugInfoSize); |
| SymLoadModule(gdbctx->process->handle, de->u.LoadDll.hFile, buffer, NULL, |
| (unsigned long)de->u.LoadDll.lpBaseOfDll, 0); |
| break; |
| |
| case UNLOAD_DLL_DEBUG_EVENT: |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) |
| fprintf(stderr, "%08lx:%08lx: unload DLL @%08lx\n", |
| de->dwProcessId, de->dwThreadId, (unsigned long)de->u.UnloadDll.lpBaseOfDll); |
| SymUnloadModule(gdbctx->process->handle, |
| (unsigned long)de->u.UnloadDll.lpBaseOfDll); |
| break; |
| |
| case EXCEPTION_DEBUG_EVENT: |
| assert(dbg_curr_thread); |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) |
| fprintf(stderr, "%08lx:%08lx: exception code=0x%08lx\n", |
| de->dwProcessId, de->dwThreadId, |
| de->u.Exception.ExceptionRecord.ExceptionCode); |
| |
| if (fetch_context(gdbctx, dbg_curr_thread->handle, &gdbctx->context)) |
| { |
| gdbctx->in_trap = handle_exception(gdbctx, &de->u.Exception); |
| } |
| break; |
| |
| case CREATE_THREAD_DEBUG_EVENT: |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) |
| fprintf(stderr, "%08lx:%08lx: create thread D @%08lx\n", |
| de->dwProcessId, de->dwThreadId, (unsigned long)(void*)de->u.CreateThread.lpStartAddress); |
| |
| dbg_add_thread(gdbctx->process, |
| de->dwThreadId, |
| de->u.CreateThread.hThread, |
| de->u.CreateThread.lpThreadLocalBase); |
| break; |
| |
| case EXIT_THREAD_DEBUG_EVENT: |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) |
| fprintf(stderr, "%08lx:%08lx: exit thread (%ld)\n", |
| de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode); |
| |
| assert(dbg_curr_thread); |
| if (dbg_curr_thread == gdbctx->exec_thread) gdbctx->exec_thread = NULL; |
| if (dbg_curr_thread == gdbctx->other_thread) gdbctx->other_thread = NULL; |
| dbg_del_thread(dbg_curr_thread); |
| break; |
| |
| case EXIT_PROCESS_DEBUG_EVENT: |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) |
| fprintf(stderr, "%08lx:%08lx: exit process (%ld)\n", |
| de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode); |
| |
| dbg_del_process(gdbctx->process); |
| gdbctx->process = NULL; |
| /* now signal gdb that we're done */ |
| gdbctx->last_sig = SIGTERM; |
| gdbctx->in_trap = TRUE; |
| break; |
| |
| case OUTPUT_DEBUG_STRING_EVENT: |
| assert(dbg_curr_thread); |
| memory_get_string(gdbctx->process->handle, |
| de->u.DebugString.lpDebugStringData, TRUE, |
| de->u.DebugString.fUnicode, buffer, sizeof(buffer)); |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) |
| fprintf(stderr, "%08lx:%08lx: output debug string (%s)\n", |
| de->dwProcessId, de->dwThreadId, buffer); |
| break; |
| |
| case RIP_EVENT: |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) |
| fprintf(stderr, "%08lx:%08lx: rip error=%ld type=%ld\n", |
| de->dwProcessId, de->dwThreadId, de->u.RipInfo.dwError, |
| de->u.RipInfo.dwType); |
| break; |
| |
| default: |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) |
| fprintf(stderr, "%08lx:%08lx: unknown event (%ld)\n", |
| de->dwProcessId, de->dwThreadId, de->dwDebugEventCode); |
| } |
| } |
| |
| static void resume_debuggee(struct gdb_context* gdbctx, unsigned long cont) |
| { |
| if (dbg_curr_thread) |
| { |
| if (!SetThreadContext(dbg_curr_thread->handle, &gdbctx->context)) |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) |
| fprintf(stderr, "Cannot set context on thread %lu\n", dbg_curr_thread->tid); |
| if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont)) |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) |
| fprintf(stderr, "Cannot continue on %lu (%lu)\n", |
| dbg_curr_thread->tid, cont); |
| } |
| else if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) |
| fprintf(stderr, "Cannot find last thread\n"); |
| } |
| |
| |
| static void resume_debuggee_thread(struct gdb_context* gdbctx, unsigned long cont, unsigned int threadid) |
| { |
| |
| if (dbg_curr_thread) |
| { |
| if(dbg_curr_thread->tid == threadid){ |
| /* Windows debug and GDB don't seem to work well here, windows only likes ContinueDebugEvent being used on the reporter of the event */ |
| if (!SetThreadContext(dbg_curr_thread->handle, &gdbctx->context)) |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) |
| fprintf(stderr, "Cannot set context on thread %lu\n", dbg_curr_thread->tid); |
| if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont)) |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) |
| fprintf(stderr, "Cannot continue on %lu (%lu)\n", |
| dbg_curr_thread->tid, cont); |
| } |
| } |
| else if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) |
| fprintf(stderr, "Cannot find last thread\n"); |
| } |
| |
| static void wait_for_debuggee(struct gdb_context* gdbctx) |
| { |
| DEBUG_EVENT de; |
| |
| gdbctx->in_trap = FALSE; |
| while (WaitForDebugEvent(&de, INFINITE)) |
| { |
| handle_debug_event(gdbctx, &de); |
| assert(!gdbctx->process || |
| gdbctx->process->pid == 0 || |
| de.dwProcessId == gdbctx->process->pid); |
| assert(!dbg_curr_thread || de.dwThreadId == dbg_curr_thread->tid); |
| if (gdbctx->in_trap) break; |
| ContinueDebugEvent(de.dwProcessId, de.dwThreadId, DBG_CONTINUE); |
| } |
| } |
| |
| static void detach_debuggee(struct gdb_context* gdbctx, BOOL kill) |
| { |
| be_cpu->single_step(&gdbctx->context, FALSE); |
| resume_debuggee(gdbctx, DBG_CONTINUE); |
| if (!kill) |
| DebugActiveProcessStop(gdbctx->process->pid); |
| dbg_del_process(gdbctx->process); |
| gdbctx->process = NULL; |
| } |
| |
| static void get_process_info(struct gdb_context* gdbctx, char* buffer, size_t len) |
| { |
| unsigned long status; |
| |
| if (!GetExitCodeProcess(gdbctx->process->handle, &status)) |
| { |
| strcpy(buffer, "Unknown process"); |
| return; |
| } |
| if (status == STILL_ACTIVE) |
| { |
| strcpy(buffer, "Running"); |
| } |
| else |
| snprintf(buffer, len, "Terminated (%lu)", status); |
| |
| switch (GetPriorityClass(gdbctx->process->handle)) |
| { |
| case 0: break; |
| #ifdef ABOVE_NORMAL_PRIORITY_CLASS |
| case ABOVE_NORMAL_PRIORITY_CLASS: strcat(buffer, ", above normal priority"); break; |
| #endif |
| #ifdef BELOW_NORMAL_PRIORITY_CLASS |
| case BELOW_NORMAL_PRIORITY_CLASS: strcat(buffer, ", below normal priotity"); break; |
| #endif |
| case HIGH_PRIORITY_CLASS: strcat(buffer, ", high priority"); break; |
| case IDLE_PRIORITY_CLASS: strcat(buffer, ", idle priority"); break; |
| case NORMAL_PRIORITY_CLASS: strcat(buffer, ", normal priority"); break; |
| case REALTIME_PRIORITY_CLASS: strcat(buffer, ", realtime priority"); break; |
| } |
| strcat(buffer, "\n"); |
| } |
| |
| static void get_thread_info(struct gdb_context* gdbctx, unsigned tid, |
| char* buffer, size_t len) |
| { |
| struct dbg_thread* thd; |
| unsigned long status; |
| int prio; |
| |
| /* FIXME: use the size of buffer */ |
| thd = dbg_get_thread(gdbctx->process, tid); |
| if (thd == NULL) |
| { |
| strcpy(buffer, "No information"); |
| return; |
| } |
| if (GetExitCodeThread(thd->handle, &status)) |
| { |
| if (status == STILL_ACTIVE) |
| { |
| /* FIXME: this is a bit brutal... some nicer way shall be found */ |
| switch (status = SuspendThread(thd->handle)) |
| { |
| case -1: break; |
| case 0: strcpy(buffer, "Running"); break; |
| default: snprintf(buffer, len, "Suspended (%lu)", status - 1); |
| } |
| ResumeThread(thd->handle); |
| } |
| else |
| snprintf(buffer, len, "Terminated (exit code = %lu)", status); |
| } |
| else |
| { |
| strcpy(buffer, "Unknown threadID"); |
| } |
| switch (prio = GetThreadPriority(thd->handle)) |
| { |
| case THREAD_PRIORITY_ERROR_RETURN: break; |
| case THREAD_PRIORITY_ABOVE_NORMAL: strcat(buffer, ", priority +1 above normal"); break; |
| case THREAD_PRIORITY_BELOW_NORMAL: strcat(buffer, ", priority -1 below normal"); break; |
| case THREAD_PRIORITY_HIGHEST: strcat(buffer, ", priority +2 above normal"); break; |
| case THREAD_PRIORITY_LOWEST: strcat(buffer, ", priority -2 below normal"); break; |
| case THREAD_PRIORITY_IDLE: strcat(buffer, ", priority idle"); break; |
| case THREAD_PRIORITY_NORMAL: strcat(buffer, ", priority normal"); break; |
| case THREAD_PRIORITY_TIME_CRITICAL: strcat(buffer, ", priority time-critical"); break; |
| default: snprintf(buffer + strlen(buffer), len - strlen(buffer), ", priority = %d", prio); |
| } |
| assert(strlen(buffer) < len); |
| } |
| |
| /* =============================================== * |
| * P A C K E T U T I L S * |
| * =============================================== * |
| */ |
| |
| enum packet_return {packet_error = 0x00, packet_ok = 0x01, packet_done = 0x02, |
| packet_last_f = 0x80}; |
| |
| static void packet_reply_grow(struct gdb_context* gdbctx, size_t size) |
| { |
| if (gdbctx->out_buf_alloc < gdbctx->out_len + size) |
| { |
| gdbctx->out_buf_alloc = ((gdbctx->out_len + size) / 32 + 1) * 32; |
| gdbctx->out_buf = realloc(gdbctx->out_buf, gdbctx->out_buf_alloc); |
| } |
| } |
| |
| static void packet_reply_hex_to(struct gdb_context* gdbctx, const void* src, int len) |
| { |
| packet_reply_grow(gdbctx, len * 2); |
| hex_to(&gdbctx->out_buf[gdbctx->out_len], src, len); |
| gdbctx->out_len += len * 2; |
| } |
| |
| static inline void packet_reply_hex_to_str(struct gdb_context* gdbctx, const char* src) |
| { |
| packet_reply_hex_to(gdbctx, src, strlen(src)); |
| } |
| |
| static void packet_reply_val(struct gdb_context* gdbctx, unsigned long val, int len) |
| { |
| int i, shift; |
| |
| shift = (len - 1) * 8; |
| packet_reply_grow(gdbctx, len * 2); |
| for (i = 0; i < len; i++, shift -= 8) |
| { |
| gdbctx->out_buf[gdbctx->out_len++] = hex_to0((val >> (shift + 4)) & 0x0F); |
| gdbctx->out_buf[gdbctx->out_len++] = hex_to0((val >> shift ) & 0x0F); |
| } |
| } |
| |
| static inline void packet_reply_add(struct gdb_context* gdbctx, const char* str, int len) |
| { |
| packet_reply_grow(gdbctx, len); |
| memcpy(&gdbctx->out_buf[gdbctx->out_len], str, len); |
| gdbctx->out_len += len; |
| } |
| |
| static inline void packet_reply_cat(struct gdb_context* gdbctx, const char* str) |
| { |
| packet_reply_add(gdbctx, str, strlen(str)); |
| } |
| |
| static inline void packet_reply_catc(struct gdb_context* gdbctx, char ch) |
| { |
| packet_reply_add(gdbctx, &ch, 1); |
| } |
| |
| static void packet_reply_open(struct gdb_context* gdbctx) |
| { |
| assert(gdbctx->out_curr_packet == -1); |
| packet_reply_catc(gdbctx, '$'); |
| gdbctx->out_curr_packet = gdbctx->out_len; |
| } |
| |
| static void packet_reply_close(struct gdb_context* gdbctx) |
| { |
| unsigned char cksum; |
| int plen; |
| |
| plen = gdbctx->out_len - gdbctx->out_curr_packet; |
| packet_reply_catc(gdbctx, '#'); |
| cksum = checksum(&gdbctx->out_buf[gdbctx->out_curr_packet], plen); |
| packet_reply_hex_to(gdbctx, &cksum, 1); |
| if (gdbctx->trace & GDBPXY_TRC_PACKET) |
| fprintf(stderr, "Reply : %*.*s\n", |
| plen, plen, &gdbctx->out_buf[gdbctx->out_curr_packet]); |
| gdbctx->out_curr_packet = -1; |
| } |
| |
| static enum packet_return packet_reply(struct gdb_context* gdbctx, const char* packet, int len) |
| { |
| packet_reply_open(gdbctx); |
| |
| if (len == -1) len = strlen(packet); |
| assert(memchr(packet, '$', len) == NULL && memchr(packet, '#', len) == NULL); |
| |
| packet_reply_add(gdbctx, packet, len); |
| |
| packet_reply_close(gdbctx); |
| |
| return packet_done; |
| } |
| |
| static enum packet_return packet_reply_error(struct gdb_context* gdbctx, int error) |
| { |
| packet_reply_open(gdbctx); |
| |
| packet_reply_add(gdbctx, "E", 1); |
| packet_reply_val(gdbctx, error, 1); |
| |
| packet_reply_close(gdbctx); |
| |
| return packet_done; |
| } |
| |
| /* =============================================== * |
| * P A C K E T H A N D L E R S * |
| * =============================================== * |
| */ |
| |
| static enum packet_return packet_reply_status(struct gdb_context* gdbctx) |
| { |
| enum packet_return ret = packet_done; |
| |
| packet_reply_open(gdbctx); |
| |
| if (gdbctx->process != NULL) |
| { |
| unsigned char sig; |
| unsigned i; |
| |
| packet_reply_catc(gdbctx, 'T'); |
| sig = gdbctx->last_sig; |
| packet_reply_val(gdbctx, sig, 1); |
| packet_reply_add(gdbctx, "thread:", 7); |
| packet_reply_val(gdbctx, dbg_curr_thread->tid, 4); |
| packet_reply_catc(gdbctx, ';'); |
| |
| for (i = 0; i < cpu_num_regs; i++) |
| { |
| /* FIXME: this call will also grow the buffer... |
| * unneeded, but not harmful |
| */ |
| packet_reply_val(gdbctx, i, 1); |
| packet_reply_catc(gdbctx, ':'); |
| packet_reply_hex_to(gdbctx, cpu_register(&gdbctx->context, i), 4); |
| packet_reply_catc(gdbctx, ';'); |
| } |
| } |
| else |
| { |
| /* Try to put an exit code |
| * Cannot use GetExitCodeProcess, wouldn't fit in a 8 bit value, so |
| * just indicate the end of process and exit */ |
| packet_reply_add(gdbctx, "W00", 3); |
| /*if (!gdbctx->extended)*/ ret |= packet_last_f; |
| } |
| |
| packet_reply_close(gdbctx); |
| |
| return ret; |
| } |
| |
| #if 0 |
| static enum packet_return packet_extended(struct gdb_context* gdbctx) |
| { |
| gdbctx->extended = 1; |
| return packet_ok; |
| } |
| #endif |
| |
| static enum packet_return packet_last_signal(struct gdb_context* gdbctx) |
| { |
| assert(gdbctx->in_packet_len == 0); |
| return packet_reply_status(gdbctx); |
| } |
| |
| static enum packet_return packet_continue(struct gdb_context* gdbctx) |
| { |
| /* FIXME: add support for address in packet */ |
| assert(gdbctx->in_packet_len == 0); |
| if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread) |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME) |
| fprintf(stderr, "NIY: cont on %lu, while last thread is %lu\n", |
| gdbctx->exec_thread->tid, dbg_curr_thread->tid); |
| resume_debuggee(gdbctx, DBG_CONTINUE); |
| wait_for_debuggee(gdbctx); |
| return packet_reply_status(gdbctx); |
| } |
| |
| static enum packet_return packet_verbose(struct gdb_context* gdbctx) |
| { |
| int i; |
| int defaultAction = -1; /* magic non action */ |
| unsigned char sig; |
| int actions =0; |
| int actionIndex[20]; /* allow for upto 20 actions */ |
| int threadIndex[20]; |
| int threadCount = 0; |
| unsigned int threadIDs[100]; /* TODO: Should make this dynamic */ |
| unsigned int threadID = 0; |
| struct dbg_thread* thd; |
| |
| /* basic check */ |
| assert(gdbctx->in_packet_len >= 4); |
| |
| /* OK we have vCont followed by.. |
| * ? for query |
| * c for packet_continue |
| * Csig for packet_continue_signal |
| * s for step |
| * Ssig for step signal |
| * and then an optional thread ID at the end.. |
| * *******************************************/ |
| |
| fprintf(stderr, "trying to process a verbose packet\n"); |
| /* now check that we've got Cont */ |
| assert(strncmp(gdbctx->in_packet, "Cont", 4) == 0); |
| |
| /* Query */ |
| if(gdbctx->in_packet[4] == '?'){ |
| /* |
| Reply: |
| `vCont[;action]...' |
| The vCont packet is supported. Each action is a supported command in the vCont packet. |
| `' |
| The vCont packet is not supported. (this didn't seem to be obayed!) |
| */ |
| packet_reply_open(gdbctx); |
| packet_reply_add(gdbctx, "vCont", 5); |
| /* add all the supported actions to the reply (all of them for now)*/ |
| packet_reply_add(gdbctx, ";c", 2); |
| packet_reply_add(gdbctx, ";C", 2); |
| packet_reply_add(gdbctx, ";s", 2); |
| packet_reply_add(gdbctx, ";S", 2); |
| packet_reply_close(gdbctx); |
| return packet_done; |
| } |
| |
| /* This may not be the 'fastest' code in the world. but it should be nice and easy to debug. |
| (as it's run when people are debugging break points I'm sure they won't notice the extra 100 cycles anyway) |
| now if only gdb talked XML.... */ |
| #if 0 /* handy for debugging */ |
| fprintf(stderr, "no, but can we find a default packet %.*s %d\n", gdbctx->in_packet_len, gdbctx->in_packet, gdbctx->in_packet_len); |
| #endif |
| |
| /* go through the packet and identify where all the actions start att */ |
| for(i = 4; i < gdbctx->in_packet_len - 1; i++){ |
| if(gdbctx->in_packet[i] == ';'){ |
| threadIndex[actions] = 0; |
| actionIndex[actions++] = i; |
| }else if(gdbctx->in_packet[i] == ':'){ |
| threadIndex[actions - 1] = i; |
| } |
| } |
| |
| /* now look up the default action */ |
| for(i = 0 ; i < actions; i++){ |
| if(threadIndex[i] == 0){ |
| if(defaultAction != -1){ |
| fprintf(stderr,"Too many default actions specified\n"); |
| return packet_error; |
| } |
| defaultAction = i; |
| } |
| } |
| |
| /* Now, I have this default action thing that needs to be applied to all non counted threads */ |
| |
| /* go through all the threads and stick there id's in the to be done list. */ |
| for (thd = gdbctx->process->threads; thd; thd = thd->next) |
| { |
| threadIDs[threadCount++] = thd->tid; |
| /* check to see if we have more threads than I counted on, and tell the user what to do |
| * (their running winedbg, so I'm sure they can fix the problem from the error message!) */ |
| if(threadCount == 100){ |
| fprintf(stderr, "Wow, that's a lot of threads, change threadIDs in wine/programms/winedgb/gdbproxy.c to be higher\n"); |
| break; |
| } |
| } |
| |
| /* Ok, now we have... actionIndex full of actions and we know what threads there are, so all |
| * that remains is to apply the actions to the threads and the default action to any threads |
| * left */ |
| if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread) |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME) |
| fprintf(stderr, "NIY: cont on %lu, while last thread is %lu\n", |
| gdbctx->exec_thread->tid, dbg_curr_thread->tid); |
| |
| /* deal with the threaded stuff first */ |
| for( i = 0; i < actions ; i++){ |
| |
| if(threadIndex[i] != 0){ |
| |
| int j, idLength = 0; |
| if(i < actions - 1){ |
| idLength = (actionIndex[i+1] - threadIndex[i]) - 1; |
| } else{ |
| idLength = (gdbctx->in_packet_len - threadIndex[i]) - 1; |
| } |
| |
| threadID = hex_to_int( gdbctx->in_packet + threadIndex[i] + 1 , idLength); |
| /* process the action */ |
| switch(gdbctx->in_packet[actionIndex[i] + 1]){ |
| case 's': /* step */ |
| be_cpu->single_step(&gdbctx->context, TRUE); |
| /* fall through*/ |
| case 'c': /* continue */ |
| resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID); |
| break; |
| case 'S': /* step Sig, */ |
| be_cpu->single_step(&gdbctx->context, TRUE); |
| /* fall through */ |
| case 'C': /* continue sig */ |
| hex_from(&sig, gdbctx->in_packet + actionIndex[i] + 2, 1); |
| /* cannot change signals on the fly */ |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND) |
| fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig); |
| if (sig != gdbctx->last_sig) |
| return packet_error; |
| resume_debuggee_thread(gdbctx, DBG_EXCEPTION_NOT_HANDLED, threadID); |
| break; |
| } |
| for(j = 0 ; j< threadCount; j++){ |
| if(threadIDs[j] == threadID){ |
| threadIDs[j] = 0; |
| break; |
| } |
| } |
| } |
| } /* for i=0 ; i< actions */ |
| |
| /* now we have manage the default action */ |
| if(defaultAction >=0){ |
| for(i = 0 ; i< threadCount; i++){ |
| /* check to see if we've already done something to the thread*/ |
| if(threadIDs[i] != 0){ |
| /* if not apply the default action*/ |
| threadID = threadIDs[i]; |
| /* process the action (yes this is almost identical to the one above!) */ |
| switch(gdbctx->in_packet[actionIndex[defaultAction] + 1]){ |
| case 's': /* step */ |
| be_cpu->single_step(&gdbctx->context, TRUE); |
| /* fall through */ |
| case 'c': /* continue */ |
| resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID); |
| break; |
| case 'S': |
| be_cpu->single_step(&gdbctx->context, TRUE); |
| /* fall through */ |
| case 'C': /* continue sig */ |
| hex_from(&sig, gdbctx->in_packet + actionIndex[defaultAction] + 2, 1); |
| /* cannot change signals on the fly */ |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND) |
| fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig); |
| if (sig != gdbctx->last_sig) |
| return packet_error; |
| resume_debuggee_thread(gdbctx, DBG_EXCEPTION_NOT_HANDLED, threadID); |
| break; |
| } |
| } |
| } |
| } /* if(defaultAction >=0) */ |
| |
| wait_for_debuggee(gdbctx); |
| be_cpu->single_step(&gdbctx->context, FALSE); |
| return packet_reply_status(gdbctx); |
| } |
| |
| static enum packet_return packet_continue_signal(struct gdb_context* gdbctx) |
| { |
| unsigned char sig; |
| |
| /* FIXME: add support for address in packet */ |
| assert(gdbctx->in_packet_len == 2); |
| if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread) |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME) |
| fprintf(stderr, "NIY: cont/sig on %lu, while last thread is %lu\n", |
| gdbctx->exec_thread->tid, dbg_curr_thread->tid); |
| hex_from(&sig, gdbctx->in_packet, 1); |
| /* cannot change signals on the fly */ |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND) |
| fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig); |
| if (sig != gdbctx->last_sig) |
| return packet_error; |
| resume_debuggee(gdbctx, DBG_EXCEPTION_NOT_HANDLED); |
| wait_for_debuggee(gdbctx); |
| return packet_reply_status(gdbctx); |
| } |
| |
| static enum packet_return packet_detach(struct gdb_context* gdbctx) |
| { |
| detach_debuggee(gdbctx, FALSE); |
| return packet_ok | packet_last_f; |
| } |
| |
| static enum packet_return packet_read_registers(struct gdb_context* gdbctx) |
| { |
| int i; |
| CONTEXT ctx; |
| CONTEXT* pctx = &gdbctx->context; |
| |
| assert(gdbctx->in_trap); |
| |
| if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread) |
| { |
| if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx)) |
| return packet_error; |
| } |
| |
| packet_reply_open(gdbctx); |
| for (i = 0; i < cpu_num_regs; i++) |
| { |
| packet_reply_hex_to(gdbctx, cpu_register(pctx, i), 4); |
| } |
| packet_reply_close(gdbctx); |
| return packet_done; |
| } |
| |
| static enum packet_return packet_write_registers(struct gdb_context* gdbctx) |
| { |
| unsigned i; |
| CONTEXT ctx; |
| CONTEXT* pctx = &gdbctx->context; |
| |
| assert(gdbctx->in_trap); |
| if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread) |
| { |
| if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx)) |
| return packet_error; |
| } |
| if (gdbctx->in_packet_len < cpu_num_regs * 2) return packet_error; |
| |
| for (i = 0; i < cpu_num_regs; i++) |
| hex_from(cpu_register(pctx, i), &gdbctx->in_packet[8 * i], 4); |
| if (pctx != &gdbctx->context && !SetThreadContext(gdbctx->other_thread->handle, pctx)) |
| { |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) |
| fprintf(stderr, "Cannot set context on thread %lu\n", gdbctx->other_thread->tid); |
| return packet_error; |
| } |
| return packet_ok; |
| } |
| |
| static enum packet_return packet_kill(struct gdb_context* gdbctx) |
| { |
| detach_debuggee(gdbctx, TRUE); |
| #if 0 |
| if (!gdbctx->extended) |
| /* dunno whether GDB cares or not */ |
| #endif |
| wait(NULL); |
| exit(0); |
| /* assume we can't really answer something here */ |
| /* return packet_done; */ |
| } |
| |
| static enum packet_return packet_thread(struct gdb_context* gdbctx) |
| { |
| char* end; |
| unsigned thread; |
| |
| switch (gdbctx->in_packet[0]) |
| { |
| case 'c': |
| case 'g': |
| if (gdbctx->in_packet[1] == '-') |
| thread = -strtol(gdbctx->in_packet + 2, &end, 16); |
| else |
| thread = strtol(gdbctx->in_packet + 1, &end, 16); |
| if (end == NULL || end > gdbctx->in_packet + gdbctx->in_packet_len) |
| { |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) |
| fprintf(stderr, "Cannot get threadid %*.*s\n", |
| gdbctx->in_packet_len - 1, gdbctx->in_packet_len - 1, |
| gdbctx->in_packet + 1); |
| return packet_error; |
| } |
| if (gdbctx->in_packet[0] == 'c') |
| gdbctx->exec_thread = dbg_get_thread(gdbctx->process, thread); |
| else |
| gdbctx->other_thread = dbg_get_thread(gdbctx->process, thread); |
| return packet_ok; |
| default: |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) |
| fprintf(stderr, "Unknown thread sub-command %c\n", gdbctx->in_packet[0]); |
| return packet_error; |
| } |
| } |
| |
| static enum packet_return packet_read_memory(struct gdb_context* gdbctx) |
| { |
| char *addr; |
| size_t len, blk_len, nread; |
| char buffer[32]; |
| unsigned long r = 0; |
| |
| assert(gdbctx->in_trap); |
| /* FIXME:check in_packet_len for reading %p,%x */ |
| if (sscanf(gdbctx->in_packet, "%p,%x", &addr, &len) != 2) return packet_error; |
| if (len <= 0) return packet_error; |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND) |
| fprintf(stderr, "Read mem at %p for %u bytes\n", addr, len); |
| for (nread = 0; nread < len; nread += r, addr += r) |
| { |
| blk_len = min(sizeof(buffer), len - nread); |
| if (!ReadProcessMemory(gdbctx->process->handle, addr, buffer, blk_len, &r) || |
| r == 0) |
| { |
| /* fail at first address, return error */ |
| if (nread == 0) return packet_reply_error(gdbctx, EFAULT); |
| /* something has already been read, return partial information */ |
| break; |
| } |
| if (nread == 0) packet_reply_open(gdbctx); |
| packet_reply_hex_to(gdbctx, buffer, r); |
| } |
| packet_reply_close(gdbctx); |
| return packet_done; |
| } |
| |
| static enum packet_return packet_write_memory(struct gdb_context* gdbctx) |
| { |
| char* addr; |
| size_t len, blk_len; |
| char* ptr; |
| char buffer[32]; |
| unsigned long w; |
| |
| assert(gdbctx->in_trap); |
| ptr = memchr(gdbctx->in_packet, ':', gdbctx->in_packet_len); |
| if (ptr == NULL) |
| { |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) |
| fprintf(stderr, "Cannot find ':' in %*.*s\n", |
| gdbctx->in_packet_len, gdbctx->in_packet_len, gdbctx->in_packet); |
| return packet_error; |
| } |
| *ptr++ = '\0'; |
| |
| if (sscanf(gdbctx->in_packet, "%p,%x", &addr, &len) != 2) |
| { |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) |
| fprintf(stderr, "Cannot scan addr,len in %s\n", gdbctx->in_packet); |
| return packet_error; |
| } |
| if (ptr - gdbctx->in_packet + len * 2 != gdbctx->in_packet_len) |
| { |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) |
| fprintf(stderr, "Wrong sizes %u <> %u\n", |
| ptr - gdbctx->in_packet + len * 2, gdbctx->in_packet_len); |
| return packet_error; |
| } |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND) |
| fprintf(stderr, "Write %u bytes at %p\n", len, addr); |
| while (len > 0) |
| { |
| blk_len = min(sizeof(buffer), len); |
| hex_from(buffer, ptr, blk_len); |
| { |
| BOOL ret; |
| |
| ret = WriteProcessMemory(gdbctx->process->handle, addr, buffer, blk_len, &w); |
| if (!ret || w != blk_len) |
| break; |
| } |
| addr += w; |
| len -= w; |
| ptr += w; |
| } |
| return packet_ok; /* FIXME: error while writing ? */ |
| } |
| |
| static enum packet_return packet_write_register(struct gdb_context* gdbctx) |
| { |
| unsigned reg; |
| char* ptr; |
| char* end; |
| CONTEXT ctx; |
| CONTEXT* pctx = &gdbctx->context; |
| |
| assert(gdbctx->in_trap); |
| |
| ptr = memchr(gdbctx->in_packet, '=', gdbctx->in_packet_len); |
| *ptr++ = '\0'; |
| reg = strtoul(gdbctx->in_packet, &end, 16); |
| if (end == NULL || reg > cpu_num_regs) |
| { |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) |
| fprintf(stderr, "Invalid register index %s\n", gdbctx->in_packet); |
| /* FIXME: if just the reg is above cpu_num_regs, don't tell gdb |
| * it wouldn't matter too much, and it fakes our support for all regs |
| */ |
| return (end == NULL) ? packet_error : packet_ok; |
| } |
| if (ptr + 8 - gdbctx->in_packet != gdbctx->in_packet_len) |
| { |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) |
| fprintf(stderr, "Wrong sizes %u <> %u\n", |
| ptr + 8 - gdbctx->in_packet, gdbctx->in_packet_len); |
| return packet_error; |
| } |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND) |
| fprintf(stderr, "Writing reg %u <= %*.*s\n", |
| reg, gdbctx->in_packet_len - (ptr - gdbctx->in_packet), |
| gdbctx->in_packet_len - (ptr - gdbctx->in_packet), ptr); |
| |
| if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread) |
| { |
| if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx)) |
| return packet_error; |
| } |
| |
| hex_from(cpu_register(pctx, reg), ptr, 4); |
| if (pctx != &gdbctx->context && !SetThreadContext(gdbctx->other_thread->handle, pctx)) |
| { |
| if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) |
| fprintf(stderr, "Cannot set context for thread %lu\n", gdbctx->other_thread->tid); |
| return packet_error; |
| } |
| |
| return packet_ok; |
| } |
| |
| static void packet_query_monitor_wnd_helper(struct gdb_context* gdbctx, HWND hWnd, int indent) |
| { |
| char buffer[128]; |
| char clsName[128]; |
| char wndName[128]; |
| HWND child; |
| |
| do { |
| if (!GetClassName(hWnd, clsName, sizeof(clsName))) |
| strcpy(clsName, "-- Unknown --"); |
| if (!GetWindowText(hWnd, wndName, sizeof(wndName))) |
| strcpy(wndName, "-- Empty --"); |
| |
| packet_reply_open(gdbctx); |
| packet_reply_catc(gdbctx, 'O'); |
| snprintf(buffer, sizeof(buffer), |
| "%*s%04x%*s%-17.17s %08lx %08lx %.14s\n", |
| indent, "", (UINT)hWnd, 13 - indent, "", |
| clsName, GetWindowLong(hWnd, GWL_STYLE), |
| GetWindowLong(hWnd, GWL_WNDPROC), wndName); |
| packet_reply_hex_to_str(gdbctx, buffer); |
| packet_reply_close(gdbctx); |
| |
| if ((child = GetWindow(hWnd, GW_CHILD)) != 0) |
| packet_query_monitor_wnd_helper(gdbctx, child, indent + 1); |
| } while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0); |
| } |
| |
| static void packet_query_monitor_wnd(struct gdb_context* gdbctx, int len, const char* str) |
| { |
| char buffer[128]; |
| |
| /* we do the output in several 'O' packets, with the last one being just OK for |
| * marking the end of the output */ |
| packet_reply_open(gdbctx); |
| packet_reply_catc(gdbctx, 'O'); |
| snprintf(buffer, sizeof(buffer), |
| "%-16.16s %-17.17s %-8.8s %s\n", |
| "hwnd", "Class Name", " Style", " WndProc Text"); |
| packet_reply_hex_to_str(gdbctx, buffer); |
| packet_reply_close(gdbctx); |
| |
| /* FIXME: could also add a pmt to this command in str... */ |
| packet_query_monitor_wnd_helper(gdbctx, GetDesktopWindow(), 0); |
| packet_reply(gdbctx, "OK", 2); |
| } |
| |
| static void packet_query_monitor_process(struct gdb_context* gdbctx, int len, const char* str) |
| { |
| HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); |
| char buffer[128]; |
| char deco; |
| PROCESSENTRY32 entry; |
| BOOL ok; |
| |
| if (snap == INVALID_HANDLE_VALUE) |
| return; |
| |
| entry.dwSize = sizeof(entry); |
| ok = Process32First(snap, &entry); |
| |
| /* we do the output in several 'O' packets, with the last one being just OK for |
| * marking the end of the output */ |
| |
| packet_reply_open(gdbctx); |
| packet_reply_catc(gdbctx, 'O'); |
| snprintf(buffer, sizeof(buffer), |
| " %-8.8s %-8.8s %-8.8s %s\n", |
| "pid", "threads", "parent", "executable"); |
| packet_reply_hex_to_str(gdbctx, buffer); |
| packet_reply_close(gdbctx); |
| |
| while (ok) |
| { |
| deco = ' '; |
| if (entry.th32ProcessID == gdbctx->process->pid) deco = '>'; |
| packet_reply_open(gdbctx); |
| packet_reply_catc(gdbctx, 'O'); |
| snprintf(buffer, sizeof(buffer), |
| "%c%08lx %-8ld %08lx '%s'\n", |
| deco, entry.th32ProcessID, entry.cntThreads, |
| entry.th32ParentProcessID, entry.szExeFile); |
| packet_reply_hex_to_str(gdbctx, buffer); |
| packet_reply_close(gdbctx); |
| ok = Process32Next(snap, &entry); |
| } |
| CloseHandle(snap); |
| packet_reply(gdbctx, "OK", 2); |
| } |
| |
| static void packet_query_monitor_mem(struct gdb_context* gdbctx, int len, const char* str) |
| { |
| MEMORY_BASIC_INFORMATION mbi; |
| char* addr = 0; |
| const char* state; |
| const char* type; |
| char prot[3+1]; |
| char buffer[128]; |
| |
| /* we do the output in several 'O' packets, with the last one being just OK for |
| * marking the end of the output */ |
| packet_reply_open(gdbctx); |
| packet_reply_catc(gdbctx, 'O'); |
| packet_reply_hex_to_str(gdbctx, "Address Size State Type RWX\n"); |
| packet_reply_close(gdbctx); |
| |
| while (VirtualQueryEx(gdbctx->process->handle, addr, &mbi, sizeof(mbi)) >= sizeof(mbi)) |
| { |
| switch (mbi.State) |
| { |
| case MEM_COMMIT: state = "commit "; break; |
| case MEM_FREE: state = "free "; break; |
| case MEM_RESERVE: state = "reserve"; break; |
| default: state = "??? "; break; |
| } |
| if (mbi.State != MEM_FREE) |
| { |
| switch (mbi.Type) |
| { |
| case MEM_IMAGE: type = "image "; break; |
| case MEM_MAPPED: type = "mapped "; break; |
| case MEM_PRIVATE: type = "private"; break; |
| case 0: type = " "; break; |
| default: type = "??? "; break; |
| } |
| memset(prot, ' ' , sizeof(prot)-1); |
| prot[sizeof(prot)-1] = '\0'; |
| if (mbi.AllocationProtect & (PAGE_READONLY|PAGE_READWRITE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE)) |
| prot[0] = 'R'; |
| if (mbi.AllocationProtect & (PAGE_READWRITE|PAGE_EXECUTE_READWRITE)) |
| prot[1] = 'W'; |
| if (mbi.AllocationProtect & (PAGE_WRITECOPY|PAGE_EXECUTE_WRITECOPY)) |
| prot[1] = 'C'; |
| if (mbi.AllocationProtect & (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE)) |
| prot[2] = 'X'; |
| } |
| else |
| { |
| type = ""; |
| prot[0] = '\0'; |
| } |
| packet_reply_open(gdbctx); |
| snprintf(buffer, sizeof(buffer), |
| "%08lx %08lx %s %s %s\n", |
| (DWORD)addr, mbi.RegionSize, state, type, prot); |
| packet_reply_catc(gdbctx, 'O'); |
| packet_reply_hex_to_str(gdbctx, buffer); |
| packet_reply_close(gdbctx); |
| |
| if (addr + mbi.RegionSize < addr) /* wrap around ? */ |
| break; |
| addr += mbi.RegionSize; |
| } |
| packet_reply(gdbctx, "OK", 2); |
| } |
| |
| static void packet_query_monitor_trace(struct gdb_context* gdbctx, |
| int len, const char* str) |
| { |
| char buffer[128]; |
| |
| if (len == 0) |
| { |
| snprintf(buffer, sizeof(buffer), "trace=%x\n", gdbctx->trace); |
| } |
| else if (len >= 2 && str[0] == '=') |
| { |
| unsigned val = atoi(&str[1]); |
| snprintf(buffer, sizeof(buffer), "trace: %x => %x\n", gdbctx->trace, val); |
| gdbctx->trace = val; |
| } |
| else |
| { |
| /* FIXME: ugly but can use error packet here */ |
| packet_reply_cat(gdbctx, "E00"); |
| return; |
| } |
| packet_reply_open(gdbctx); |
| packet_reply_hex_to_str(gdbctx, buffer); |
| packet_reply_close(gdbctx); |
| } |
| |
| struct query_detail |
| { |
| int with_arg; |
| const char* name; |
| size_t len; |
| void (*handler)(struct gdb_context*, int, const char*); |
| } query_details[] = |
| { |
| {0, "wnd", 3, packet_query_monitor_wnd}, |
| {0, "window", 6, packet_query_monitor_wnd}, |
| {0, "proc", 4, packet_query_monitor_process}, |
| {0, "process", 7, packet_query_monitor_process}, |
| {0, "mem", 3, packet_query_monitor_mem}, |
| {1, "trace", 5, packet_query_monitor_trace}, |
| {0, NULL, 0, NULL}, |
| }; |
| |
| static enum packet_return packet_query_remote_command(struct gdb_context* gdbctx, |
| const char* hxcmd, size_t len) |
| { |
| char buffer[128]; |
| struct query_detail* qd; |
| |
| assert((len & 1) == 0 && len < 2 * sizeof(buffer)); |
| len /= 2; |
| hex_from(buffer, hxcmd, len); |
| |
| for (qd = &query_details[0]; qd->name != NULL; qd++) |
| { |
| if (len < qd->len || strncmp(buffer, qd->name, qd->len) != 0) continue; |
| if (!qd->with_arg && len != qd->len) continue; |
| |
| (qd->handler)(gdbctx, len - qd->len, buffer + qd->len); |
| return packet_done; |
| } |
| return packet_reply_error(gdbctx, EINVAL); |
| } |
| |
| static enum packet_return packet_query(struct gdb_context* gdbctx) |
| { |
| switch (gdbctx->in_packet[0]) |
| { |
| case 'f': |
| if (strncmp(gdbctx->in_packet + 1, "ThreadInfo", gdbctx->in_packet_len - 1) == 0) |
| { |
| struct dbg_thread* thd; |
| |
| packet_reply_open(gdbctx); |
| packet_reply_add(gdbctx, "m", 1); |
| for (thd = gdbctx->process->threads; thd; thd = thd->next) |
| { |
| packet_reply_val(gdbctx, thd->tid, 4); |
| if (thd->next != NULL) |
| packet_reply_add(gdbctx, ",", 1); |
| } |
| packet_reply_close(gdbctx); |
| return packet_done; |
| } |
| else if (strncmp(gdbctx->in_packet + 1, "ProcessInfo", gdbctx->in_packet_len - 1) == 0) |
| { |
| char result[128]; |
| |
| packet_reply_open(gdbctx); |
| packet_reply_catc(gdbctx, 'O'); |
| get_process_info(gdbctx, result, sizeof(result)); |
| packet_reply_hex_to_str(gdbctx, result); |
| packet_reply_close(gdbctx); |
| return packet_done; |
| } |
| break; |
| case 's': |
| if (strncmp(gdbctx->in_packet + 1, "ThreadInfo", gdbctx->in_packet_len - 1) == 0) |
| { |
| packet_reply(gdbctx, "l", 1); |
| return packet_done; |
| } |
| else if (strncmp(gdbctx->in_packet + 1, "ProcessInfo", gdbctx->in_packet_len - 1) == 0) |
| { |
| packet_reply(gdbctx, "l", 1); |
| return packet_done; |
| } |
| break; |
| case 'C': |
| if (gdbctx->in_packet_len == 1) |
| { |
| struct dbg_thread* thd; |
| /* FIXME: doc says 16 bit val ??? */ |
| /* grab first created thread, aka last in list */ |
| assert(gdbctx->process && gdbctx->process->threads); |
| for (thd = gdbctx->process->threads; thd->next; thd = thd->next); |
| packet_reply_open(gdbctx); |
| packet_reply_add(gdbctx, "QC", 2); |
| packet_reply_val(gdbctx, thd->tid, 4); |
| packet_reply_close(gdbctx); |
| return packet_done; |
| } |
| break; |
| case 'O': |
| if (strncmp(gdbctx->in_packet, "Offsets", gdbctx->in_packet_len) == 0) |
| { |
| char buf[64]; |
| |
| if (gdbctx->wine_segs[0] == 0 && gdbctx->wine_segs[1] == 0 && |
| gdbctx->wine_segs[2] == 0) |
| return packet_error; |
| snprintf(buf, sizeof(buf), |
| "Text=%08lx;Data=%08lx;Bss=%08lx", |
| gdbctx->wine_segs[0], gdbctx->wine_segs[1], |
| gdbctx->wine_segs[2]); |
| return packet_reply(gdbctx, buf, -1); |
| } |
| break; |
| case 'R': |
| if (gdbctx->in_packet_len > 5 && strncmp(gdbctx->in_packet, "Rcmd,", 5) == 0) |
| { |
| return packet_query_remote_command(gdbctx, gdbctx->in_packet + 5, |
| gdbctx->in_packet_len - 5); |
| } |
| break; |
| case 'S': |
| if (strncmp(gdbctx->in_packet, "Symbol::", gdbctx->in_packet_len) == 0) |
| return packet_ok; |
| break; |
| case 'T': |
| if (gdbctx->in_packet_len > 15 && |
| strncmp(gdbctx->in_packet, "ThreadExtraInfo", 15) == 0 && |
| gdbctx->in_packet[15] == ',') |
| { |
| unsigned tid; |
| char* end; |
| char result[128]; |
| |
| tid = strtol(gdbctx->in_packet + 16, &end, 16); |
| if (end == NULL) break; |
| get_thread_info(gdbctx, tid, result, sizeof(result)); |
| packet_reply_open(gdbctx); |
| packet_reply_hex_to_str(gdbctx, result); |
| packet_reply_close(gdbctx); |
| return packet_done; |
| } |
| break; |
| } |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) |
| fprintf(stderr, "Unknown or malformed query %*.*s\n", |
| gdbctx->in_packet_len, gdbctx->in_packet_len, gdbctx->in_packet); |
| return packet_error; |
| } |
| |
| static enum packet_return packet_step(struct gdb_context* gdbctx) |
| { |
| /* FIXME: add support for address in packet */ |
| assert(gdbctx->in_packet_len == 0); |
| if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread) |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME) |
| fprintf(stderr, "NIY: step on %lu, while last thread is %lu\n", |
| gdbctx->exec_thread->tid, dbg_curr_thread->tid); |
| be_cpu->single_step(&gdbctx->context, TRUE); |
| resume_debuggee(gdbctx, DBG_CONTINUE); |
| wait_for_debuggee(gdbctx); |
| be_cpu->single_step(&gdbctx->context, FALSE); |
| return packet_reply_status(gdbctx); |
| } |
| |
| #if 0 |
| static enum packet_return packet_step_signal(struct gdb_context* gdbctx) |
| { |
| unsigned char sig; |
| |
| /* FIXME: add support for address in packet */ |
| assert(gdbctx->in_packet_len == 2); |
| if (dbg_curr_thread->tid != gdbctx->exec_thread && gdbctx->exec_thread) |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) |
| fprintf(stderr, "NIY: step/sig on %u, while last thread is %u\n", |
| gdbctx->exec_thread, DEBUG_CurrThread->tid); |
| hex_from(&sig, gdbctx->in_packet, 1); |
| /* cannot change signals on the fly */ |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND) |
| fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig); |
| if (sig != gdbctx->last_sig) |
| return packet_error; |
| resume_debuggee(gdbctx, DBG_EXCEPTION_NOT_HANDLED); |
| wait_for_debuggee(gdbctx); |
| return packet_reply_status(gdbctx); |
| } |
| #endif |
| |
| static enum packet_return packet_thread_alive(struct gdb_context* gdbctx) |
| { |
| char* end; |
| unsigned tid; |
| |
| tid = strtol(gdbctx->in_packet, &end, 16); |
| if (tid == -1 || tid == 0) |
| return packet_reply_error(gdbctx, EINVAL); |
| if (dbg_get_thread(gdbctx->process, tid) != NULL) |
| return packet_ok; |
| return packet_reply_error(gdbctx, ESRCH); |
| } |
| |
| static enum packet_return packet_remove_breakpoint(struct gdb_context* gdbctx) |
| { |
| void* addr; |
| unsigned len; |
| struct gdb_ctx_Xpoint* xpt; |
| enum be_xpoint_type t; |
| |
| /* FIXME: check packet_len */ |
| if (gdbctx->in_packet[0] < '0' || gdbctx->in_packet[0] > '4' || |
| gdbctx->in_packet[1] != ',' || |
| sscanf(gdbctx->in_packet + 2, "%p,%x", &addr, &len) != 2) |
| return packet_error; |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND) |
| fprintf(stderr, "Remove bp %p[%u] typ=%c\n", |
| addr, len, gdbctx->in_packet[0]); |
| switch (gdbctx->in_packet[0]) |
| { |
| case '0': t = be_xpoint_break; len = 0; break; |
| case '1': t = be_xpoint_watch_exec; break; |
| case '2': t = be_xpoint_watch_read; break; |
| case '3': t = be_xpoint_watch_write; break; |
| default: return packet_error; |
| } |
| for (xpt = &gdbctx->Xpoints[NUM_XPOINT - 1]; xpt >= gdbctx->Xpoints; xpt--) |
| { |
| if (xpt->addr == addr && xpt->type == t) |
| { |
| if (be_cpu->remove_Xpoint(gdbctx->process->handle, &gdbctx->context, |
| t, xpt->addr, xpt->val, len)) |
| { |
| xpt->type = -1; |
| return packet_ok; |
| } |
| break; |
| } |
| } |
| return packet_error; |
| } |
| |
| static enum packet_return packet_set_breakpoint(struct gdb_context* gdbctx) |
| { |
| void* addr; |
| unsigned len; |
| struct gdb_ctx_Xpoint* xpt; |
| enum be_xpoint_type t; |
| |
| /* FIXME: check packet_len */ |
| if (gdbctx->in_packet[0] < '0' || gdbctx->in_packet[0] > '4' || |
| gdbctx->in_packet[1] != ',' || |
| sscanf(gdbctx->in_packet + 2, "%p,%x", &addr, &len) != 2) |
| return packet_error; |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND) |
| fprintf(stderr, "Set bp %p[%u] typ=%c\n", |
| addr, len, gdbctx->in_packet[0]); |
| switch (gdbctx->in_packet[0]) |
| { |
| case '0': t = be_xpoint_break; len = 0; break; |
| case '1': t = be_xpoint_watch_exec; break; |
| case '2': t = be_xpoint_watch_read; break; |
| case '3': t = be_xpoint_watch_write; break; |
| default: return packet_error; |
| } |
| /* because of packet command handling, this should be made idempotent */ |
| for (xpt = &gdbctx->Xpoints[NUM_XPOINT - 1]; xpt >= gdbctx->Xpoints; xpt--) |
| { |
| if (xpt->addr == addr && xpt->type == t) |
| return packet_ok; /* nothing to do */ |
| } |
| /* really set the Xpoint */ |
| for (xpt = &gdbctx->Xpoints[NUM_XPOINT - 1]; xpt >= gdbctx->Xpoints; xpt--) |
| { |
| if (xpt->type == -1) |
| { |
| if (be_cpu->insert_Xpoint(gdbctx->process->handle, &gdbctx->context, |
| t, addr, &xpt->val, len)) |
| { |
| xpt->addr = addr; |
| xpt->type = t; |
| return packet_ok; |
| } |
| fprintf(stderr, "cannot set xpoint\n"); |
| break; |
| } |
| } |
| /* no more entries... eech */ |
| fprintf(stderr, "Running out of spots for {break|watch}points\n"); |
| return packet_error; |
| } |
| |
| /* =============================================== * |
| * P A C K E T I N F R A S T R U C T U R E * |
| * =============================================== * |
| */ |
| |
| struct packet_entry |
| { |
| char key; |
| enum packet_return (*handler)(struct gdb_context* gdbctx); |
| }; |
| |
| static struct packet_entry packet_entries[] = |
| { |
| /*{'!', packet_extended}, */ |
| {'?', packet_last_signal}, |
| {'c', packet_continue}, |
| {'C', packet_continue_signal}, |
| {'D', packet_detach}, |
| {'g', packet_read_registers}, |
| {'G', packet_write_registers}, |
| {'k', packet_kill}, |
| {'H', packet_thread}, |
| {'m', packet_read_memory}, |
| {'M', packet_write_memory}, |
| /* {'p', packet_read_register}, doesn't seem needed */ |
| {'P', packet_write_register}, |
| {'q', packet_query}, |
| /* {'Q', packet_set}, */ |
| /* {'R', packet,restart}, only in extended mode ! */ |
| {'s', packet_step}, |
| /*{'S', packet_step_signal}, hard(er) to implement */ |
| {'T', packet_thread_alive}, |
| {'v', packet_verbose}, |
| {'z', packet_remove_breakpoint}, |
| {'Z', packet_set_breakpoint}, |
| }; |
| |
| static BOOL extract_packets(struct gdb_context* gdbctx) |
| { |
| char* end; |
| int plen; |
| unsigned char in_cksum, loc_cksum; |
| char* ptr; |
| enum packet_return ret = packet_error; |
| int num_packet = 0; |
| |
| while ((ret & packet_last_f) == 0) |
| { |
| if (gdbctx->in_len && (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)) |
| fprintf(stderr, "In-buf: %*.*s\n", |
| gdbctx->in_len, gdbctx->in_len, gdbctx->in_buf); |
| ptr = memchr(gdbctx->in_buf, '$', gdbctx->in_len); |
| if (ptr == NULL) return FALSE; |
| if (ptr != gdbctx->in_buf) |
| { |
| int glen = ptr - gdbctx->in_buf; /* garbage len */ |
| if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) |
| fprintf(stderr, "Removing garbage: %*.*s\n", |
| glen, glen, gdbctx->in_buf); |
| gdbctx->in_len -= glen; |
| memmove(gdbctx->in_buf, ptr, gdbctx->in_len); |
| } |
| end = memchr(gdbctx->in_buf + 1, '#', gdbctx->in_len); |
| if (end == NULL) return FALSE; |
| /* no checksum yet */ |
| if (end + 3 > gdbctx->in_buf + gdbctx->in_len) return FALSE; |
| plen = end - gdbctx->in_buf - 1; |
| hex_from(&in_cksum, end + 1, 1); |
| loc_cksum = checksum(gdbctx->in_buf + 1, plen); |
| if (loc_cksum == in_cksum) |
| { |
| if (num_packet == 0) { |
| int i; |
| |
| ret = packet_error; |
| |
| write(gdbctx->sock, "+", 1); |
| assert(plen); |
| |
| /* FIXME: should use bsearch if packet_entries was sorted */ |
| for (i = 0; i < sizeof(packet_entries)/sizeof(packet_entries[0]); i++) |
| { |
| if (packet_entries[i].key == gdbctx->in_buf[1]) break; |
| } |
| if (i == sizeof(packet_entries)/sizeof(packet_entries[0])) |
| { |
| if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR) |
| fprintf(stderr, "Unknown packet request %*.*s\n", |
| plen, plen, &gdbctx->in_buf[1]); |
| } |
| else |
| { |
| gdbctx->in_packet = gdbctx->in_buf + 2; |
| gdbctx->in_packet_len = plen - 1; |
| if (gdbctx->trace & GDBPXY_TRC_PACKET) |
| fprintf(stderr, "Packet: %c%*.*s\n", |
| gdbctx->in_buf[1], |
| gdbctx->in_packet_len, gdbctx->in_packet_len, |
| gdbctx->in_packet); |
| ret = (packet_entries[i].handler)(gdbctx); |
| } |
| switch (ret & ~packet_last_f) |
| { |
| case packet_error: packet_reply(gdbctx, "", 0); break; |
| case packet_ok: packet_reply(gdbctx, "OK", 2); break; |
| case packet_done: break; |
| } |
| if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) |
| fprintf(stderr, "Reply-full: %*.*s\n", |
| gdbctx->out_len, gdbctx->out_len, gdbctx->out_buf); |
| i = write(gdbctx->sock, gdbctx->out_buf, gdbctx->out_len); |
| assert(i == gdbctx->out_len); |
| /* if this fails, we'll have to use POLLOUT... |
| */ |
| gdbctx->out_len = 0; |
| num_packet++; |
| } |
| else |
| { |
| /* FIXME: if we have in our input buffer more than one packet, |
| * it's very likely that we took too long to answer to a given packet |
| * and gdb is sending us again the same packet |
| * We simply drop the second packet. This will lower the risk of error, |
| * but there's still some race conditions here |
| * A better fix (yet not perfect) would be to have two threads: |
| * - one managing the packets for gdb |
| * - the second one managing the commands... |
| * This would allow us also the reply with the '+' character (Ack of |
| * the command) way sooner than what we do now |
| */ |
| if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) |
| fprintf(stderr, "Dropping packet, I was too slow to respond\n"); |
| } |
| } |
| else |
| { |
| write(gdbctx->sock, "+", 1); |
| if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) |
| fprintf(stderr, "Dropping packet, invalid checksum %d <> %d\n", in_cksum, loc_cksum); |
| } |
| gdbctx->in_len -= plen + 4; |
| memmove(gdbctx->in_buf, end + 3, gdbctx->in_len); |
| } |
| return TRUE; |
| } |
| |
| static int fetch_data(struct gdb_context* gdbctx) |
| { |
| int len, in_len = gdbctx->in_len; |
| |
| assert(gdbctx->in_len <= gdbctx->in_buf_alloc); |
| for (;;) |
| { |
| #define STEP 128 |
| if (gdbctx->in_len + STEP > gdbctx->in_buf_alloc) |
| gdbctx->in_buf = realloc(gdbctx->in_buf, gdbctx->in_buf_alloc += STEP); |
| #undef STEP |
| if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) |
| fprintf(stderr, "%d %d %*.*s\n", |
| gdbctx->in_len, gdbctx->in_buf_alloc, |
| gdbctx->in_len, gdbctx->in_len, gdbctx->in_buf); |
| len = read(gdbctx->sock, gdbctx->in_buf + gdbctx->in_len, gdbctx->in_buf_alloc - gdbctx->in_len); |
| if (len <= 0) break; |
| gdbctx->in_len += len; |
| assert(gdbctx->in_len <= gdbctx->in_buf_alloc); |
| if (len < gdbctx->in_buf_alloc - gdbctx->in_len) break; |
| } |
| if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) |
| fprintf(stderr, "=> %d\n", gdbctx->in_len - in_len); |
| return gdbctx->in_len - in_len; |
| } |
| |
| static BOOL gdb_exec(const char* wine_path, unsigned port, unsigned flags) |
| { |
| char buf[MAX_PATH]; |
| int fd; |
| const char* gdb_path; |
| FILE* f; |
| |
| if (!(gdb_path = getenv("WINE_GDB"))) gdb_path = "gdb"; |
| strcpy(buf,"/tmp/winegdb.XXXXXX"); |
| fd = mkstemps(buf, 0); |
| if (fd == -1) return FALSE; |
| if ((f = fdopen(fd, "w+")) == NULL) return FALSE; |
| fprintf(f, "file %s\n", wine_path); |
| fprintf(f, "target remote localhost:%d\n", ntohs(port)); |
| fprintf(f, "monitor trace=%d\n", GDBPXY_TRC_COMMAND_FIXME); |
| fprintf(f, "set prompt Wine-gdb>\\ \n"); |
| /* gdb 5.1 seems to require it, won't hurt anyway */ |
| fprintf(f, "sharedlibrary\n"); |
| /* This is needed (but not a decent & final fix) |
| * Without this, gdb would skip our inter-DLL relay code (because |
| * we don't have any line number information for the relay code) |
| * With this, we will stop on first instruction of the stub, and |
| * reusing step, will get us through the relay stub at the actual |
| * function we're looking at. |
| */ |
| fprintf(f, "set step-mode on\n"); |
| /* tell gdb to delete this file when done handling it... */ |
| fprintf(f, "shell rm -f \"%s\"\n", buf); |
| fclose(f); |
| if (flags & 2) |
| execlp("xterm", "xterm", "-e", gdb_path, "-x", buf, NULL); |
| else |
| execlp(gdb_path, gdb_path, "-x", buf, NULL); |
| assert(0); /* never reached */ |
| return TRUE; |
| } |
| |
| static BOOL gdb_startup(struct gdb_context* gdbctx, DEBUG_EVENT* de, unsigned flags) |
| { |
| int sock; |
| struct sockaddr_in s_addrs; |
| int s_len = sizeof(s_addrs); |
| struct pollfd pollfd; |
| IMAGEHLP_MODULE imh_mod; |
| |
| /* step 1: create socket for gdb connection request */ |
| if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) |
| { |
| if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) |
| fprintf(stderr, "Can't create socket"); |
| return FALSE; |
| } |
| |
| if (listen(sock, 1) == -1 || |
| getsockname(sock, (struct sockaddr*)&s_addrs, &s_len) == -1) |
| return FALSE; |
| |
| /* step 2: do the process internal creation */ |
| handle_debug_event(gdbctx, de); |
| |
| /* step3: get the wine loader name */ |
| if (!dbg_get_debuggee_info(gdbctx->process->handle, &imh_mod)) return FALSE; |
| |
| /* step 4: fire up gdb (if requested) */ |
| if (flags & 1) |
| fprintf(stderr, "target remote localhost:%d\n", ntohs(s_addrs.sin_port)); |
| else |
| switch (fork()) |
| { |
| case -1: /* error in parent... */ |
| fprintf(stderr, "Cannot create gdb\n"); |
| return FALSE; |
| break; |
| default: /* in parent... success */ |
| break; |
| case 0: /* in child... and alive */ |
| gdb_exec(imh_mod.LoadedImageName, s_addrs.sin_port, flags); |
| /* if we're here, exec failed, so report failure */ |
| return FALSE; |
| } |
| |
| /* step 5: wait for gdb to connect actually */ |
| pollfd.fd = sock; |
| pollfd.events = POLLIN; |
| pollfd.revents = 0; |
| |
| switch (poll(&pollfd, 1, -1)) |
| { |
| case 1: |
| if (pollfd.revents & POLLIN) |
| { |
| int dummy = 1; |
| gdbctx->sock = accept(sock, (struct sockaddr*)&s_addrs, &s_len); |
| if (gdbctx->sock == -1) |
| break; |
| if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) |
| fprintf(stderr, "Connected on %d\n", gdbctx->sock); |
| /* don't keep our small packets too long: send them ASAP back to GDB |
| * without this, GDB really crawls |
| */ |
| setsockopt(gdbctx->sock, IPPROTO_TCP, TCP_NODELAY, (char*)&dummy, sizeof(dummy)); |
| } |
| break; |
| case 0: |
| if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) |
| fprintf(stderr, "Poll for cnx failed (timeout)\n"); |
| return FALSE; |
| case -1: |
| if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL) |
| fprintf(stderr, "Poll for cnx failed (error)\n"); |
| return FALSE; |
| default: |
| assert(0); |
| } |
| |
| close(sock); |
| return TRUE; |
| } |
| |
| static BOOL gdb_init_context(struct gdb_context* gdbctx, unsigned flags) |
| { |
| DEBUG_EVENT de; |
| int i; |
| |
| gdbctx->sock = -1; |
| gdbctx->in_buf = NULL; |
| gdbctx->in_buf_alloc = 0; |
| gdbctx->in_len = 0; |
| gdbctx->out_buf = NULL; |
| gdbctx->out_buf_alloc = 0; |
| gdbctx->out_len = 0; |
| gdbctx->out_curr_packet = -1; |
| |
| gdbctx->exec_thread = gdbctx->other_thread = NULL; |
| gdbctx->last_sig = 0; |
| gdbctx->in_trap = FALSE; |
| gdbctx->trace = /*GDBPXY_TRC_PACKET | GDBPXY_TRC_COMMAND |*/ GDBPXY_TRC_COMMAND_ERROR | GDBPXY_TRC_COMMAND_FIXME | GDBPXY_TRC_WIN32_EVENT; |
| gdbctx->process = NULL; |
| for (i = 0; i < NUM_XPOINT; i++) |
| gdbctx->Xpoints[i].type = -1; |
| |
| /* wait for first trap */ |
| while (WaitForDebugEvent(&de, INFINITE)) |
| { |
| if (de.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT) |
| { |
| /* this should be the first event we get, |
| * and the only one of this type */ |
| assert(gdbctx->process == NULL && de.dwProcessId == dbg_curr_pid); |
| /* gdbctx->dwProcessId = pid; */ |
| if (!gdb_startup(gdbctx, &de, flags)) return FALSE; |
| assert(!gdbctx->in_trap); |
| } |
| else |
| { |
| handle_debug_event(gdbctx, &de); |
| if (gdbctx->in_trap) break; |
| } |
| ContinueDebugEvent(de.dwProcessId, de.dwThreadId, DBG_CONTINUE); |
| } |
| return TRUE; |
| } |
| |
| BOOL gdb_remote(unsigned flags) |
| { |
| struct pollfd pollfd; |
| struct gdb_context gdbctx; |
| BOOL doLoop; |
| |
| for (doLoop = gdb_init_context(&gdbctx, flags); doLoop;) |
| { |
| pollfd.fd = gdbctx.sock; |
| pollfd.events = POLLIN; |
| pollfd.revents = 0; |
| |
| switch (poll(&pollfd, 1, -1)) |
| { |
| case 1: |
| /* got something */ |
| if (pollfd.revents & (POLLHUP | POLLERR)) |
| { |
| if (gdbctx.trace & GDBPXY_TRC_LOWLEVEL) |
| fprintf(stderr, "Gdb hung up\n"); |
| /* kill also debuggee process - questionnable - */ |
| detach_debuggee(&gdbctx, TRUE); |
| doLoop = FALSE; |
| break; |
| } |
| if ((pollfd.revents & POLLIN) && fetch_data(&gdbctx) > 0) |
| { |
| if (extract_packets(&gdbctx)) doLoop = FALSE; |
| } |
| break; |
| case 0: |
| /* timeout, should never happen (infinite timeout) */ |
| break; |
| case -1: |
| if (gdbctx.trace & GDBPXY_TRC_LOWLEVEL) |
| fprintf(stderr, "Poll failed\n"); |
| doLoop = FALSE; |
| break; |
| } |
| } |
| wait(NULL); |
| return 0; |
| } |
