/* * 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-2003 * * 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 { int 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 */ DBG_THREAD* exec_thread; /* thread used in step & continue */ 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 */ 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 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 * * =============================================== * */ #define OFFSET_OF(__c,__f) ((int)(((char*)&(((__c*)0)->__f))-((char*)0))) #ifdef __i386__ static size_t cpu_register_map[] = { OFFSET_OF(CONTEXT, Eax), OFFSET_OF(CONTEXT, Ecx), OFFSET_OF(CONTEXT, Edx), OFFSET_OF(CONTEXT, Ebx), OFFSET_OF(CONTEXT, Esp), OFFSET_OF(CONTEXT, Ebp), OFFSET_OF(CONTEXT, Esi), OFFSET_OF(CONTEXT, Edi), OFFSET_OF(CONTEXT, Eip), OFFSET_OF(CONTEXT, EFlags), OFFSET_OF(CONTEXT, SegCs), OFFSET_OF(CONTEXT, SegSs), OFFSET_OF(CONTEXT, SegDs), OFFSET_OF(CONTEXT, SegEs), OFFSET_OF(CONTEXT, SegFs), OFFSET_OF(CONTEXT, SegGs), }; #else # ifdef __powerpc__ static size_t cpu_register_map[] = { OFFSET_OF(CONTEXT, Gpr0), OFFSET_OF(CONTEXT, Gpr1), OFFSET_OF(CONTEXT, Gpr2), OFFSET_OF(CONTEXT, Gpr3), OFFSET_OF(CONTEXT, Gpr4), OFFSET_OF(CONTEXT, Gpr5), OFFSET_OF(CONTEXT, Gpr6), OFFSET_OF(CONTEXT, Gpr7), OFFSET_OF(CONTEXT, Gpr8), OFFSET_OF(CONTEXT, Gpr9), OFFSET_OF(CONTEXT, Gpr10), OFFSET_OF(CONTEXT, Gpr11), OFFSET_OF(CONTEXT, Gpr12), OFFSET_OF(CONTEXT, Gpr13), OFFSET_OF(CONTEXT, Gpr14), OFFSET_OF(CONTEXT, Gpr15), OFFSET_OF(CONTEXT, Gpr16), OFFSET_OF(CONTEXT, Gpr17), OFFSET_OF(CONTEXT, Gpr18), OFFSET_OF(CONTEXT, Gpr19), OFFSET_OF(CONTEXT, Gpr20), OFFSET_OF(CONTEXT, Gpr21), OFFSET_OF(CONTEXT, Gpr22), OFFSET_OF(CONTEXT, Gpr23), OFFSET_OF(CONTEXT, Gpr24), OFFSET_OF(CONTEXT, Gpr25), OFFSET_OF(CONTEXT, Gpr26), OFFSET_OF(CONTEXT, Gpr27), OFFSET_OF(CONTEXT, Gpr28), OFFSET_OF(CONTEXT, Gpr29), OFFSET_OF(CONTEXT, Gpr30), OFFSET_OF(CONTEXT, Gpr31), OFFSET_OF(CONTEXT, Fpr0), OFFSET_OF(CONTEXT, Fpr1), OFFSET_OF(CONTEXT, Fpr2), OFFSET_OF(CONTEXT, Fpr3), OFFSET_OF(CONTEXT, Fpr4), OFFSET_OF(CONTEXT, Fpr5), OFFSET_OF(CONTEXT, Fpr6), OFFSET_OF(CONTEXT, Fpr7), OFFSET_OF(CONTEXT, Fpr8), OFFSET_OF(CONTEXT, Fpr9), OFFSET_OF(CONTEXT, Fpr10), OFFSET_OF(CONTEXT, Fpr11), OFFSET_OF(CONTEXT, Fpr12), OFFSET_OF(CONTEXT, Fpr13), OFFSET_OF(CONTEXT, Fpr14), OFFSET_OF(CONTEXT, Fpr15), OFFSET_OF(CONTEXT, Fpr16), OFFSET_OF(CONTEXT, Fpr17), OFFSET_OF(CONTEXT, Fpr18), OFFSET_OF(CONTEXT, Fpr19), OFFSET_OF(CONTEXT, Fpr20), OFFSET_OF(CONTEXT, Fpr21), OFFSET_OF(CONTEXT, Fpr22), OFFSET_OF(CONTEXT, Fpr23), OFFSET_OF(CONTEXT, Fpr24), OFFSET_OF(CONTEXT, Fpr25), OFFSET_OF(CONTEXT, Fpr26), OFFSET_OF(CONTEXT, Fpr27), OFFSET_OF(CONTEXT, Fpr28), OFFSET_OF(CONTEXT, Fpr29), OFFSET_OF(CONTEXT, Fpr30), OFFSET_OF(CONTEXT, Fpr31), OFFSET_OF(CONTEXT, Iar), OFFSET_OF(CONTEXT, Msr), OFFSET_OF(CONTEXT, Cr), OFFSET_OF(CONTEXT, Lr), OFFSET_OF(CONTEXT, Ctr), OFFSET_OF(CONTEXT, Xer), /* FIXME: MQ is missing? OFFSET_OF(CONTEXT, Mq), */ /* see gdb/nlm/ppc.c */ }; # else # error "Define the registers map for your CPU" # endif #endif #undef OFFSET_OF static const size_t cpu_num_regs = (sizeof(cpu_register_map) / sizeof(cpu_register_map[0])); static inline unsigned long* cpu_register(const CONTEXT* ctx, unsigned idx) { assert(idx < cpu_num_regs); return (unsigned long*)((char*)ctx + cpu_register_map[idx]); } static inline BOOL cpu_enter_stepping(struct gdb_context* gdbctx) { #ifdef __i386__ gdbctx->context.EFlags |= 0x100; return TRUE; #elif __powerpc__ #ifndef MSR_SE # define MSR_SE (1<<10) #endif gdbctx->context.Msr |= MSR_SE; return TRUE; #else #error "Define step mode enter for your CPU" #endif return FALSE; } static inline BOOL cpu_leave_stepping(struct gdb_context* gdbctx) { #ifdef __i386__ /* The Win32 debug API always resets the Step bit in EFlags after * a single step instruction, so we don't need to clear when the * step is done. */ return TRUE; #elif __powerpc__ gdbctx->context.Msr &= MSR_SE; return TRUE; #else #error "Define step mode leave for your CPU" #endif return FALSE; } #ifdef __i386__ #define DR7_CONTROL_SHIFT 16 #define DR7_CONTROL_SIZE 4 #define DR7_RW_EXECUTE (0x0) #define DR7_RW_WRITE (0x1) #define DR7_RW_READ (0x3) #define DR7_LEN_1 (0x0) #define DR7_LEN_2 (0x4) #define DR7_LEN_4 (0xC) #define DR7_LOCAL_ENABLE_SHIFT 0 #define DR7_GLOBAL_ENABLE_SHIFT 1 #define DR7_ENABLE_SIZE 2 #define DR7_LOCAL_ENABLE_MASK (0x55) #define DR7_GLOBAL_ENABLE_MASK (0xAA) #define DR7_CONTROL_RESERVED (0xFC00) #define DR7_LOCAL_SLOWDOWN (0x100) #define DR7_GLOBAL_SLOWDOWN (0x200) #define DR7_ENABLE_MASK(dr) (1<<(DR7_LOCAL_ENABLE_SHIFT+DR7_ENABLE_SIZE*(dr))) #define IS_DR7_SET(ctrl,dr) ((ctrl)&DR7_ENABLE_MASK(dr)) static inline int i386_get_unused_DR(struct gdb_context* gdbctx, unsigned long** r) { if (!IS_DR7_SET(gdbctx->context.Dr7, 0)) { *r = &gdbctx->context.Dr0; return 0; } if (!IS_DR7_SET(gdbctx->context.Dr7, 1)) { *r = &gdbctx->context.Dr1; return 1; } if (!IS_DR7_SET(gdbctx->context.Dr7, 2)) { *r = &gdbctx->context.Dr2; return 2; } if (!IS_DR7_SET(gdbctx->context.Dr7, 3)) { *r = &gdbctx->context.Dr3; return 3; } return -1; } #endif /****************************************************************** * cpu_insert_Xpoint * * returns 1 if ok * 0 if error * -1 if operation isn't supported by CPU */ static inline int cpu_insert_Xpoint(struct gdb_context* gdbctx, struct gdb_ctx_Xpoint* xpt, size_t len) { #ifdef __i386__ unsigned char ch; unsigned long sz; unsigned long* pr; int reg; unsigned long bits; switch (xpt->type) { case '0': if (len != 1) return 0; if (!ReadProcessMemory(gdbctx->process->handle, xpt->addr, &ch, 1, &sz) || sz != 1) return 0; xpt->val = ch; ch = 0xcc; if (!WriteProcessMemory(gdbctx->process->handle, xpt->addr, &ch, 1, &sz) || sz != 1) return 0; break; case '1': bits = DR7_RW_EXECUTE; goto hw_bp; case '2': bits = DR7_RW_READ; goto hw_bp; case '3': bits = DR7_RW_WRITE; hw_bp: if ((reg = i386_get_unused_DR(gdbctx, &pr)) == -1) return 0; *pr = (unsigned long)xpt->addr; if (xpt->type != '1') switch (len) { case 4: bits |= DR7_LEN_4; break; case 2: bits |= DR7_LEN_2; break; case 1: bits |= DR7_LEN_1; break; default: return 0; } xpt->val = reg; /* clear old values */ gdbctx->context.Dr7 &= ~(0x0F << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg)); /* set the correct ones */ gdbctx->context.Dr7 |= bits << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg); gdbctx->context.Dr7 |= DR7_ENABLE_MASK(reg) | DR7_LOCAL_SLOWDOWN; break; default: fprintf(stderr, "Unknown bp type %c\n", xpt->type); return 0; } return 1; #elif defined(__powerpc__) unsigned long xbp; unsigned long sz; switch (xpt->type) { case '0': if (len != 4) return 0; if (!ReadProcessMemory(gdbctx->process->handle, xpt->addr, &xbp, 4, &sz) || sz != 4) return 0; xpt->val = xbp; xbp = 0x7d821008; /* 7d 82 10 08 ... in big endian */ if (!WriteProcessMemory(gdbctx->process->handle, xpt->addr, &xbp, 4, &sz) || sz != 4) return 0; break; default: fprintf(stderr, "Unknown/unsupported bp type %c\n", xpt->type); return 0; } return 1; #else #error "Define insert Xpoint for your CPU" #endif return -1; } /****************************************************************** * cpu_remove_Xpoint * * returns 1 if ok * 0 if error * -1 if operation isn't supported by CPU */ static inline BOOL cpu_remove_Xpoint(struct gdb_context* gdbctx, struct gdb_ctx_Xpoint* xpt, size_t len) { #ifdef __i386__ unsigned long sz; unsigned char ch; switch (xpt->type) { case '0': if (len != 1) return 0; ch = (unsigned char)xpt->val; if (!WriteProcessMemory(gdbctx->process->handle, xpt->addr, &ch, 1, &sz) || sz != 1) return 0; break; case '1': case '2': case '3': /* simply disable the entry */ gdbctx->context.Dr7 &= ~DR7_ENABLE_MASK(xpt->val); break; default: fprintf(stderr, "Unknown bp type %c\n", xpt->type); return 0; } return 1; #elif defined(__powerpc__) unsigned long sz; unsigned long xbp; switch (xpt->type) { case '0': if (len != 4) return 0; xbp = xpt->val; if (!WriteProcessMemory(gdbctx->process->handle, xpt->addr, &xbp, 4, &sz) || sz != 4) return 0; break; case '1': case '2': case '3': default: fprintf(stderr, "Unknown/unsupported bp type %c\n", xpt->type); return 0; } return 1; #else #error "Define remove Xpoint for your CPU" #endif return -1; } /* =============================================== * * 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 %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]; DEBUG_CurrThread = DEBUG_GetThread(gdbctx->process, de->dwThreadId); switch (de->dwDebugEventCode) { case CREATE_PROCESS_DEBUG_EVENT: DEBUG_ProcessGetStringIndirect(buffer, sizeof(buffer), de->u.CreateProcessInfo.hProcess, de->u.CreateProcessInfo.lpImageName, de->u.CreateProcessInfo.fUnicode); /* FIXME unicode ? de->u.CreateProcessInfo.fUnicode */ 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)(LPVOID)de->u.CreateProcessInfo.lpStartAddress, de->u.CreateProcessInfo.dwDebugInfoFileOffset, de->u.CreateProcessInfo.nDebugInfoSize); gdbctx->process = DEBUG_AddProcess(de->dwProcessId, de->u.CreateProcessInfo.hProcess, buffer); /* de->u.CreateProcessInfo.lpStartAddress; */ if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) fprintf(stderr, "%08lx:%08lx: create thread I @%08lx\n", de->dwProcessId, de->dwThreadId, (unsigned long)(LPVOID)de->u.CreateProcessInfo.lpStartAddress); assert(DEBUG_CurrThread == NULL); /* shouldn't be there */ DEBUG_AddThread(gdbctx->process, de->dwThreadId, de->u.CreateProcessInfo.hThread, de->u.CreateProcessInfo.lpStartAddress, de->u.CreateProcessInfo.lpThreadLocalBase); break; case LOAD_DLL_DEBUG_EVENT: assert(DEBUG_CurrThread); DEBUG_ProcessGetStringIndirect(buffer, sizeof(buffer), gdbctx->process->handle, de->u.LoadDll.lpImageName, de->u.LoadDll.fUnicode); /* FIXME unicode: de->u.LoadDll.fUnicode */ 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); #if 0 _strupr(buffer); DEBUG_LoadModule32(buffer, de->u.LoadDll.hFile, de->u.LoadDll.lpBaseOfDll); DEBUG_CheckDelayedBP(); if (DBG_IVAR(BreakOnDllLoad)) { DEBUG_Printf("Stopping on DLL %s loading at %08lx\n", buffer, (unsigned long)de->u.LoadDll.lpBaseOfDll); DEBUG_Parser(); } #endif 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); break; case EXCEPTION_DEBUG_EVENT: assert(DEBUG_CurrThread); if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT) fprintf(stderr, "%08lx:%08lx: exception code=%08lx\n", de->dwProcessId, de->dwThreadId, de->u.Exception.ExceptionRecord.ExceptionCode); if (fetch_context(gdbctx, DEBUG_CurrThread->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)(LPVOID)de->u.CreateThread.lpStartAddress); DEBUG_AddThread(gdbctx->process, de->dwThreadId, de->u.CreateThread.hThread, de->u.CreateThread.lpStartAddress, 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(DEBUG_CurrThread); if (DEBUG_CurrThread == gdbctx->exec_thread) gdbctx->exec_thread = NULL; if (DEBUG_CurrThread == gdbctx->other_thread) gdbctx->other_thread = NULL; DEBUG_DelThread(DEBUG_CurrThread); 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); DEBUG_DelProcess(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(DEBUG_CurrThread); DEBUG_ProcessGetString(buffer, sizeof(buffer), gdbctx->process->handle, de->u.DebugString.lpDebugStringData); /* FIXME unicode de->u.DebugString.fUnicode ? */ 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 (DEBUG_CurrThread) { if (!SetThreadContext(DEBUG_CurrThread->handle, &gdbctx->context)) if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) fprintf(stderr, "Cannot set context on thread %lu\n", DEBUG_CurrThread->tid); if (!ContinueDebugEvent(gdbctx->process->pid, DEBUG_CurrThread->tid, cont)) if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) fprintf(stderr, "Cannot continue on %lu (%lu)\n", DEBUG_CurrThread->tid, cont); } else if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR) fprintf(stderr, "Cannot find last thread (%lu)\n", DEBUG_CurrThread->tid); } 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(!DEBUG_CurrThread || de.dwThreadId == DEBUG_CurrThread->tid); if (gdbctx->in_trap) break; ContinueDebugEvent(de.dwProcessId, de.dwThreadId, DBG_CONTINUE); } } static void detach_debuggee(struct gdb_context* gdbctx, BOOL kill) { cpu_leave_stepping(gdbctx); resume_debuggee(gdbctx, DBG_CONTINUE); if (!kill) DebugActiveProcessStop(gdbctx->process->pid); DEBUG_DelProcess(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) { DBG_THREAD* thd; unsigned long status; int prio; /* FIXME: use the size of buffer */ thd = DEBUG_GetThread(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, DEBUG_CurrThread->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 (DEBUG_CurrThread != 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, DEBUG_CurrThread->tid); resume_debuggee(gdbctx, DBG_CONTINUE); wait_for_debuggee(gdbctx); 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 (DEBUG_CurrThread != 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, 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); } 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 (DEBUG_CurrThread != 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 (DEBUG_CurrThread != 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 = DEBUG_GetThread(gdbctx->process, thread); else gdbctx->other_thread = DEBUG_GetThread(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 (gdbctx->trace & GDBPXY_TRC_COMMAND) fprintf(stderr, "Read mem at %p for %u bytes\n", addr, len); for (nread = 0; nread < len > 0; 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 (DEBUG_CurrThread != 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); } #ifdef __i386__ static void packet_query_monitor_linear(struct gdb_context* gdbctx, int len, const char* str) { unsigned seg, ofs; LDT_ENTRY le; unsigned linear; char buffer[32]; while (len > 0 && (*str == ' ' || *str == '\t')) { str++; len--; } /* FIXME: do a better scanning (allow both decimal and hex numbers) */ if (!len || sscanf(str, "%x:%x", &seg, &ofs) != 2) { packet_reply_error(gdbctx, 0); return; } /* V86 mode ? */ if (gdbctx->context.EFlags & 0x00020000) linear = (LOWORD(seg) << 4) + ofs; /* linux system selector ? */ else if (!(seg & 4) || ((seg >> 3) < 17)) linear = ofs; /* standard selector */ else if (GetThreadSelectorEntry(gdbctx->process->threads->handle, seg, &le)) linear = (le.HighWord.Bits.BaseHi << 24) + (le.HighWord.Bits.BaseMid << 16) + le.BaseLow + ofs; /* error */ else linear = 0; snprintf(buffer, sizeof(buffer), "0x%x", linear); packet_reply_open(gdbctx); packet_reply_hex_to_str(gdbctx, buffer); packet_reply_close(gdbctx); } #endif 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}, #ifdef __i386__ {1, "linear", 6, packet_query_monitor_linear}, #endif {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) { 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) { 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 (DEBUG_CurrThread != 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, DEBUG_CurrThread->tid); if (!cpu_enter_stepping(gdbctx)) return packet_error; resume_debuggee(gdbctx, DBG_CONTINUE); wait_for_debuggee(gdbctx); if (!cpu_leave_stepping(gdbctx)) return packet_error; 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 (DEBUG_CurrThread->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 (DEBUG_GetThread(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; /* 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]); for (xpt = &gdbctx->Xpoints[NUM_XPOINT - 1]; xpt >= gdbctx->Xpoints; xpt--) { if (xpt->addr == addr && xpt->type == gdbctx->in_packet[0]) { switch (cpu_remove_Xpoint(gdbctx, xpt, len)) { case 1: xpt->type = -1; return packet_ok; case 0: return packet_error; case -1: return packet_done; default: assert(0); } } } return packet_error; } static enum packet_return packet_set_breakpoint(struct gdb_context* gdbctx) { void* addr; unsigned len; struct gdb_ctx_Xpoint* xpt; /* 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]); /* 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 == gdbctx->in_packet[0]) 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) { xpt->addr = addr; xpt->type = gdbctx->in_packet[0]; switch (cpu_insert_Xpoint(gdbctx, xpt, len)) { case 1: return packet_ok; case 0: return packet_error; case -1: return packet_done; default: assert(0); } } } /* 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}, {'s', packet_step}, /*{'S', packet_step_signal}, hard(er) to implement */ {'T', packet_thread_alive}, {'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_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; char wine_path[MAX_PATH]; struct elf_info elf_info; /* 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: find out wine executable location (as a Unix filename) */ elf_info.flags = ELF_INFO_PATH | ELF_INFO_SEGMENTS; elf_info.elf_path = wine_path; elf_info.elf_path_len = sizeof(wine_path); if (DEBUG_ReadWineLoaderDbgInfo(de->u.CreateProcessInfo.hProcess, &elf_info) == DIL_ERROR) return FALSE; gdbctx->wine_segs[0] = elf_info.segments[0]; gdbctx->wine_segs[1] = elf_info.segments[1]; gdbctx->wine_segs[2] = elf_info.segments[2]; fprintf(stderr, "Using wine_path: %s\n", wine_path); /* step 3: 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 */ { 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(s_addrs.sin_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"); /* 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 */ break; } break; } /* step 4: do the process internal creation */ handle_debug_event(gdbctx, de); /* 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 == DEBUG_CurrPid); /*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 DEBUG_GdbRemote(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; }