dlls/kernel32/debugger.c

   1 /*
   2  * Win32 debugger functions
   3  *
   4  * Copyright (C) 1999 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include <stdio.h>
  23 #include <string.h>
  24
  25 #include "ntstatus.h"
  26 #define WIN32_NO_STATUS
  27 #include "winerror.h"
  28 #include "wine/server.h"
  29 #include "kernel_private.h"
  30 #include "wine/debug.h"
  31 #include "wine/exception.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(debugstr);
  34
  35
  36 /******************************************************************************
  37  *           WaitForDebugEvent   (KERNEL32.@)
  38  *
  39  *  Waits for a debugging event to occur in a process being debugged before
  40  *  filling out the debug event structure.
  41  *
  42  * PARAMS
  43  *  event   [O] Address of structure for event information.
  44  *  timeout [I] Number of milliseconds to wait for event.
  45  *
  46  * RETURNS
  47  *
  48  *  Returns true if a debug event occurred and false if the call timed out.
  49  */
  50 BOOL WINAPI WaitForDebugEvent(
  51     LPDEBUG_EVENT event,
  52     DWORD         timeout)
  53 {
  54     BOOL ret;
  55     DWORD res;
  56     int i;
  57
  58     for (;;)
  59     {
  60         HANDLE wait = 0;
  61         debug_event_t data;
  62         SERVER_START_REQ( wait_debug_event )
  63         {
  64             req->get_handle = (timeout != 0);
  65             wine_server_set_reply( req, &data, sizeof(data) );
  66             if (!(ret = !wine_server_call_err( req ))) goto done;
  67
  68             if (!wine_server_reply_size(reply))  /* timeout */
  69             {
  70                 wait = wine_server_ptr_handle( reply->wait );
  71                 ret = FALSE;
  72                 goto done;
  73             }
  74             event->dwDebugEventCode = data.code;
  75             event->dwProcessId      = (DWORD)reply->pid;
  76             event->dwThreadId       = (DWORD)reply->tid;
  77             switch(data.code)
  78             {
  79             case EXCEPTION_DEBUG_EVENT:
  80                 if (data.exception.exc_code == DBG_PRINTEXCEPTION_C && data.exception.nb_params >= 2)
  81                 {
  82                     event->dwDebugEventCode = OUTPUT_DEBUG_STRING_EVENT;
  83                     event->u.DebugString.lpDebugStringData  = wine_server_get_ptr( data.exception.params[1] );
  84                     event->u.DebugString.fUnicode           = FALSE;
  85                     event->u.DebugString.nDebugStringLength = data.exception.params[0];
  86                     break;
  87                 }
  88                 else if (data.exception.exc_code == DBG_RIPEXCEPTION && data.exception.nb_params >= 2)
  89                 {
  90                     event->dwDebugEventCode = RIP_EVENT;
  91                     event->u.RipInfo.dwError = data.exception.params[0];
  92                     event->u.RipInfo.dwType  = data.exception.params[1];
  93                     break;
  94                 }
  95                 event->u.Exception.dwFirstChance = data.exception.first;
  96                 event->u.Exception.ExceptionRecord.ExceptionCode    = data.exception.exc_code;
  97                 event->u.Exception.ExceptionRecord.ExceptionFlags   = data.exception.flags;
  98                 event->u.Exception.ExceptionRecord.ExceptionRecord  = wine_server_get_ptr( data.exception.record );
  99                 event->u.Exception.ExceptionRecord.ExceptionAddress = wine_server_get_ptr( data.exception.address );
 100                 event->u.Exception.ExceptionRecord.NumberParameters = data.exception.nb_params;
 101                 for (i = 0; i < data.exception.nb_params; i++)
 102                     event->u.Exception.ExceptionRecord.ExceptionInformation[i] = data.exception.params[i];
 103                 break;
 104             case CREATE_THREAD_DEBUG_EVENT:
 105                 event->u.CreateThread.hThread           = wine_server_ptr_handle( data.create_thread.handle );
 106                 event->u.CreateThread.lpThreadLocalBase = wine_server_get_ptr( data.create_thread.teb );
 107                 event->u.CreateThread.lpStartAddress    = wine_server_get_ptr( data.create_thread.start );
 108                 break;
 109             case CREATE_PROCESS_DEBUG_EVENT:
 110                 event->u.CreateProcessInfo.hFile                 = wine_server_ptr_handle( data.create_process.file );
 111                 event->u.CreateProcessInfo.hProcess              = wine_server_ptr_handle( data.create_process.process );
 112                 event->u.CreateProcessInfo.hThread               = wine_server_ptr_handle( data.create_process.thread );
 113                 event->u.CreateProcessInfo.lpBaseOfImage         = wine_server_get_ptr( data.create_process.base );
 114                 event->u.CreateProcessInfo.dwDebugInfoFileOffset = data.create_process.dbg_offset;
 115                 event->u.CreateProcessInfo.nDebugInfoSize        = data.create_process.dbg_size;
 116                 event->u.CreateProcessInfo.lpThreadLocalBase     = wine_server_get_ptr( data.create_process.teb );
 117                 event->u.CreateProcessInfo.lpStartAddress        = wine_server_get_ptr( data.create_process.start );
 118                 event->u.CreateProcessInfo.lpImageName           = wine_server_get_ptr( data.create_process.name );
 119                 event->u.CreateProcessInfo.fUnicode              = data.create_process.unicode;
 120                 break;
 121             case EXIT_THREAD_DEBUG_EVENT:
 122                 event->u.ExitThread.dwExitCode = data.exit.exit_code;
 123                 break;
 124             case EXIT_PROCESS_DEBUG_EVENT:
 125                 event->u.ExitProcess.dwExitCode = data.exit.exit_code;
 126                 break;
 127             case LOAD_DLL_DEBUG_EVENT:
 128                 event->u.LoadDll.hFile                 = wine_server_ptr_handle( data.load_dll.handle );
 129                 event->u.LoadDll.lpBaseOfDll           = wine_server_get_ptr( data.load_dll.base );
 130                 event->u.LoadDll.dwDebugInfoFileOffset = data.load_dll.dbg_offset;
 131                 event->u.LoadDll.nDebugInfoSize        = data.load_dll.dbg_size;
 132                 event->u.LoadDll.lpImageName           = wine_server_get_ptr( data.load_dll.name );
 133                 event->u.LoadDll.fUnicode              = data.load_dll.unicode;
 134                 break;
 135             case UNLOAD_DLL_DEBUG_EVENT:
 136                 event->u.UnloadDll.lpBaseOfDll = wine_server_get_ptr( data.unload_dll.base );
 137                 break;
 138             }
 139         done:
 140             /* nothing */ ;
 141         }
 142         SERVER_END_REQ;
 143         if (ret) return TRUE;
 144         if (!wait) break;
 145         res = WaitForSingleObject( wait, timeout );
 146         CloseHandle( wait );
 147         if (res != STATUS_WAIT_0) break;
 148     }
 149     SetLastError( ERROR_SEM_TIMEOUT );
 150     return FALSE;
 151 }
 152
 153
 154 /**********************************************************************
 155  *           ContinueDebugEvent   (KERNEL32.@)
 156  *
 157  *  Enables a thread that previously produced a debug event to continue.
 158  *
 159  * PARAMS
 160  *  pid    [I] The id of the process to continue.
 161  *  tid    [I] The id of the thread to continue.
 162  *  status [I] The rule to apply to unhandled exceptions.
 163  *
 164  * RETURNS
 165  *
 166  *  True if the debugger is listed as the processes owner and the process
 167  *  and thread are valid.
 168  */
 169 BOOL WINAPI ContinueDebugEvent(
 170     DWORD pid,
 171     DWORD tid,
 172     DWORD status)
 173 {
 174     BOOL ret;
 175     SERVER_START_REQ( continue_debug_event )
 176     {
 177         req->pid    = pid;
 178         req->tid    = tid;
 179         req->status = status;
 180         ret = !wine_server_call_err( req );
 181     }
 182     SERVER_END_REQ;
 183     return ret;
 184 }
 185
 186
 187 /**********************************************************************
 188  *           DebugActiveProcess   (KERNEL32.@)
 189  *
 190  *  Attempts to attach the debugger to a process.
 191  *
 192  * PARAMS
 193  *  pid [I] The process to be debugged.
 194  *
 195  * RETURNS
 196  *
 197  *  True if the debugger was attached to process.
 198  */
 199 BOOL WINAPI DebugActiveProcess( DWORD pid )
 200 {
 201     BOOL ret;
 202     SERVER_START_REQ( debug_process )
 203     {
 204         req->pid = pid;
 205         req->attach = 1;
 206         ret = !wine_server_call_err( req );
 207     }
 208     SERVER_END_REQ;
 209     return ret;
 210 }
 211
 212 /**********************************************************************
 213  *           DebugActiveProcessStop   (KERNEL32.@)
 214  *
 215  *  Attempts to detach the debugger from a process.
 216  *
 217  * PARAMS
 218  *  pid [I] The process to be detached.
 219  *
 220  * RETURNS
 221  *
 222  *  True if the debugger was detached from the process.
 223  */
 224 BOOL WINAPI DebugActiveProcessStop( DWORD pid )
 225 {
 226     BOOL ret;
 227     SERVER_START_REQ( debug_process )
 228     {
 229         req->pid = pid;
 230         req->attach = 0;
 231         ret = !wine_server_call_err( req );
 232     }
 233     SERVER_END_REQ;
 234     return ret;
 235 }
 236
 237 static LONG WINAPI debug_exception_handler( EXCEPTION_POINTERS *eptr )
 238 {
 239     EXCEPTION_RECORD *rec = eptr->ExceptionRecord;
 240     return (rec->ExceptionCode == DBG_PRINTEXCEPTION_C) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
 241 }
 242
 243 /***********************************************************************
 244  *           OutputDebugStringA   (KERNEL32.@)
 245  *
 246  *  Output by an application of an ascii string to a debugger (if attached)
 247  *  and program log.
 248  *
 249  * PARAMS
 250  *  str [I] The message to be logged and given to the debugger.
 251  *
 252  * RETURNS
 253  *
 254  *  Nothing.
 255  */
 256 void WINAPI OutputDebugStringA( LPCSTR str )
 257 {
 258     static HANDLE DBWinMutex = NULL;
 259     static BOOL mutex_inited = FALSE;
 260     BOOL caught_by_dbg = TRUE;
 261
 262     if (!str) str = "";
 263     WARN("%s\n", debugstr_a(str));
 264
 265     /* raise exception, WaitForDebugEvent() will generate a corresponding debug event */
 266     __TRY
 267     {
 268         ULONG_PTR args[2];
 269         args[0] = strlen(str) + 1;
 270         args[1] = (ULONG_PTR)str;
 271         RaiseException( DBG_PRINTEXCEPTION_C, 0, 2, args );
 272     }
 273     __EXCEPT(debug_exception_handler)
 274     {
 275         caught_by_dbg = FALSE;
 276     }
 277     __ENDTRY
 278     if (caught_by_dbg) return;
 279
 280     /* send string to a system-wide monitor */
 281     if (!mutex_inited)
 282     {
 283         /* first call to OutputDebugString, initialize mutex handle */
 284         static const WCHAR mutexname[] = {'D','B','W','i','n','M','u','t','e','x',0};
 285         HANDLE mutex = CreateMutexExW( NULL, mutexname, 0, SYNCHRONIZE );
 286         if (mutex)
 287         {
 288             if (InterlockedCompareExchangePointer( &DBWinMutex, mutex, 0 ) != 0)
 289             {
 290                 /* someone beat us here... */
 291                 CloseHandle( mutex );
 292             }
 293         }
 294         mutex_inited = TRUE;
 295     }
 296
 297     if (DBWinMutex)
 298     {
 299         static const WCHAR shmname[] = {'D','B','W','I','N','_','B','U','F','F','E','R',0};
 300         static const WCHAR eventbuffername[] = {'D','B','W','I','N','_','B','U','F','F','E','R','_','R','E','A','D','Y',0};
 301         static const WCHAR eventdataname[] = {'D','B','W','I','N','_','D','A','T','A','_','R','E','A','D','Y',0};
 302         HANDLE mapping;
 303
 304         mapping = OpenFileMappingW( FILE_MAP_WRITE, FALSE, shmname );
 305         if (mapping)
 306         {
 307             LPVOID buffer;
 308             HANDLE eventbuffer, eventdata;
 309
 310             buffer = MapViewOfFile( mapping, FILE_MAP_WRITE, 0, 0, 0 );
 311             eventbuffer = OpenEventW( SYNCHRONIZE, FALSE, eventbuffername );
 312             eventdata = OpenEventW( EVENT_MODIFY_STATE, FALSE, eventdataname );
 313
 314             if (buffer && eventbuffer && eventdata)
 315             {
 316                 /* monitor is present, synchronize with other OutputDebugString invocations */
 317                 WaitForSingleObject( DBWinMutex, INFINITE );
 318
 319                 /* acquire control over the buffer */
 320                 if (WaitForSingleObject( eventbuffer, 10000 ) == WAIT_OBJECT_0)
 321                 {
 322                     int str_len;
 323                     struct _mon_buffer_t {
 324                         DWORD pid;
 325                         char buffer[1];
 326                     } *mon_buffer = (struct _mon_buffer_t*) buffer;
 327
 328                     str_len = strlen( str );
 329                     if (str_len > (4096 - sizeof(DWORD) - 1))
 330                         str_len = 4096 - sizeof(DWORD) - 1;
 331
 332                     mon_buffer->pid = GetCurrentProcessId();
 333                     memcpy( mon_buffer->buffer, str, str_len );
 334                     mon_buffer->buffer[str_len] = 0;
 335
 336                     /* signal data ready */
 337                     SetEvent( eventdata );
 338                 }
 339                 ReleaseMutex( DBWinMutex );
 340             }
 341
 342             if (buffer)
 343                 UnmapViewOfFile( buffer );
 344             if (eventbuffer)
 345                 CloseHandle( eventbuffer );
 346             if (eventdata)
 347                 CloseHandle( eventdata );
 348             CloseHandle( mapping );
 349         }
 350     }
 351 }
 352
 353
 354 /***********************************************************************
 355  *           OutputDebugStringW   (KERNEL32.@)
 356  *
 357  *  Output by an application of a unicode string to a debugger (if attached)
 358  *  and program log.
 359  *
 360  * PARAMS
 361  *  str [I] The message to be logged and given to the debugger.
 362  *
 363  * RETURNS
 364  *
 365  *  Nothing.
 366  */
 367 void WINAPI OutputDebugStringW( LPCWSTR str )
 368 {
 369     UNICODE_STRING strW;
 370     STRING strA;
 371
 372     RtlInitUnicodeString( &strW, str );
 373     if (!RtlUnicodeStringToAnsiString( &strA, &strW, TRUE ))
 374     {
 375         OutputDebugStringA( strA.Buffer );
 376         RtlFreeAnsiString( &strA );
 377     }
 378 }
 379
 380
 381 /***********************************************************************
 382  *           DebugBreak   (KERNEL32.@)
 383  *
 384  *  Raises an exception so that a debugger (if attached)
 385  *  can take some action.
 386  */
 387 #if defined(__i386__) || defined(__x86_64__)
 388 __ASM_STDCALL_FUNC( DebugBreak, 0, "jmp " __ASM_NAME("DbgBreakPoint") )
 389 #else
 390 void WINAPI DebugBreak(void)
 391 {
 392     DbgBreakPoint();
 393 }
 394 #endif
 395
 396 /***********************************************************************
 397  *           DebugBreakProcess   (KERNEL32.@)
 398  *
 399  *  Raises an exception so that a debugger (if attached)
 400  *  can take some action. Same as DebugBreak, but applies to any process.
 401  *
 402  * PARAMS
 403  *  hProc [I] Process to break into.
 404  *
 405  * RETURNS
 406  *
 407  *  True if successful.
 408  */
 409 BOOL WINAPI DebugBreakProcess(HANDLE hProc)
 410 {
 411     BOOL ret, self;
 412
 413     TRACE("(%p)\n", hProc);
 414
 415     SERVER_START_REQ( debug_break )
 416     {
 417         req->handle = wine_server_obj_handle( hProc );
 418         ret = !wine_server_call_err( req );
 419         self = ret && reply->self;
 420     }
 421     SERVER_END_REQ;
 422     if (self) DbgBreakPoint();
 423     return ret;
 424 }
 425
 426
 427 /***********************************************************************
 428  *           IsDebuggerPresent   (KERNEL32.@)
 429  *
 430  *  Allows a process to determine if there is a debugger attached.
 431  *
 432  * PARAMS
 433  *
 434  * RETURNS
 435  *
 436  *  True if there is a debugger attached.
 437  */
 438 BOOL WINAPI IsDebuggerPresent(void)
 439 {
 440     return NtCurrentTeb()->Peb->BeingDebugged;
 441 }
 442
 443 /***********************************************************************
 444  *           CheckRemoteDebuggerPresent   (KERNEL32.@)
 445  *
 446  *  Allows a process to determine if there is a remote debugger
 447  *  attached.
 448  *
 449  * PARAMS
 450  *
 451  * RETURNS
 452  *
 453  *  TRUE because it is a stub.
 454  */
 455 BOOL WINAPI CheckRemoteDebuggerPresent(HANDLE process, PBOOL DebuggerPresent)
 456 {
 457     NTSTATUS status;
 458     DWORD_PTR port;
 459
 460     if(!process || !DebuggerPresent)
 461     {
 462         SetLastError(ERROR_INVALID_PARAMETER);
 463         return FALSE;
 464     }
 465
 466     status = NtQueryInformationProcess(process, ProcessDebugPort, &port, sizeof(port), NULL);
 467     if (status != STATUS_SUCCESS)
 468     {
 469         SetLastError(RtlNtStatusToDosError(status));
 470         return FALSE;
 471     }
 472
 473     *DebuggerPresent = !!port;
 474     return TRUE;
 475 }
 476
 477 /***********************************************************************
 478  *           DebugSetProcessKillOnExit                    (KERNEL32.@)
 479  *
 480  * Let a debugger decide whether a debuggee will be killed upon debugger
 481  * termination.
 482  *
 483  * PARAMS
 484  *  kill [I] If set to true then kill the process on exit.
 485  *
 486  * RETURNS
 487  *  True if successful, false otherwise.
 488  */
 489 BOOL WINAPI DebugSetProcessKillOnExit(BOOL kill)
 490 {
 491     BOOL ret = FALSE;
 492
 493     SERVER_START_REQ( set_debugger_kill_on_exit )
 494     {
 495         req->kill_on_exit = kill;
 496         ret = !wine_server_call_err( req );
 497     }
 498     SERVER_END_REQ;
 499     return ret;
 500 }