2 * Win32 debugger functions
4 * Copyright (C) 1999 Alexandre Julliard
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.
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.
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
26 #define WIN32_NO_STATUS
28 #include "wine/server.h"
29 #include "kernel_private.h"
30 #include "wine/debug.h"
32 WINE_DEFAULT_DEBUG_CHANNEL(debugstr);
35 /******************************************************************************
36 * WaitForDebugEvent (KERNEL32.@)
38 * Waits for a debugging event to occur in a process being debugged before
39 * filling out the debug event structure.
42 * event [O] Address of structure for event information.
43 * timeout [I] Number of milliseconds to wait for event.
47 * Returns true if a debug event occurred and false if the call timed out.
49 BOOL WINAPI WaitForDebugEvent(
61 SERVER_START_REQ( wait_debug_event )
63 req->get_handle = (timeout != 0);
64 wine_server_set_reply( req, &data, sizeof(data) );
65 if (!(ret = !wine_server_call_err( req ))) goto done;
67 if (!wine_server_reply_size(reply)) /* timeout */
69 wait = wine_server_ptr_handle( reply->wait );
73 event->dwDebugEventCode = data.code;
74 event->dwProcessId = (DWORD)reply->pid;
75 event->dwThreadId = (DWORD)reply->tid;
78 case EXCEPTION_DEBUG_EVENT:
79 event->u.Exception.dwFirstChance = data.exception.first;
80 event->u.Exception.ExceptionRecord.ExceptionCode = data.exception.exc_code;
81 event->u.Exception.ExceptionRecord.ExceptionFlags = data.exception.flags;
82 event->u.Exception.ExceptionRecord.ExceptionRecord = wine_server_get_ptr( data.exception.record );
83 event->u.Exception.ExceptionRecord.ExceptionAddress = wine_server_get_ptr( data.exception.address );
84 event->u.Exception.ExceptionRecord.NumberParameters = data.exception.nb_params;
85 for (i = 0; i < data.exception.nb_params; i++)
86 event->u.Exception.ExceptionRecord.ExceptionInformation[i] = data.exception.params[i];
88 case CREATE_THREAD_DEBUG_EVENT:
89 event->u.CreateThread.hThread = wine_server_ptr_handle( data.create_thread.handle );
90 event->u.CreateThread.lpThreadLocalBase = wine_server_get_ptr( data.create_thread.teb );
91 event->u.CreateThread.lpStartAddress = wine_server_get_ptr( data.create_thread.start );
93 case CREATE_PROCESS_DEBUG_EVENT:
94 event->u.CreateProcessInfo.hFile = wine_server_ptr_handle( data.create_process.file );
95 event->u.CreateProcessInfo.hProcess = wine_server_ptr_handle( data.create_process.process );
96 event->u.CreateProcessInfo.hThread = wine_server_ptr_handle( data.create_process.thread );
97 event->u.CreateProcessInfo.lpBaseOfImage = wine_server_get_ptr( data.create_process.base );
98 event->u.CreateProcessInfo.dwDebugInfoFileOffset = data.create_process.dbg_offset;
99 event->u.CreateProcessInfo.nDebugInfoSize = data.create_process.dbg_size;
100 event->u.CreateProcessInfo.lpThreadLocalBase = wine_server_get_ptr( data.create_process.teb );
101 event->u.CreateProcessInfo.lpStartAddress = wine_server_get_ptr( data.create_process.start );
102 event->u.CreateProcessInfo.lpImageName = wine_server_get_ptr( data.create_process.name );
103 event->u.CreateProcessInfo.fUnicode = data.create_process.unicode;
105 case EXIT_THREAD_DEBUG_EVENT:
106 event->u.ExitThread.dwExitCode = data.exit.exit_code;
108 case EXIT_PROCESS_DEBUG_EVENT:
109 event->u.ExitProcess.dwExitCode = data.exit.exit_code;
111 case LOAD_DLL_DEBUG_EVENT:
112 event->u.LoadDll.hFile = wine_server_ptr_handle( data.load_dll.handle );
113 event->u.LoadDll.lpBaseOfDll = wine_server_get_ptr( data.load_dll.base );
114 event->u.LoadDll.dwDebugInfoFileOffset = data.load_dll.dbg_offset;
115 event->u.LoadDll.nDebugInfoSize = data.load_dll.dbg_size;
116 event->u.LoadDll.lpImageName = wine_server_get_ptr( data.load_dll.name );
117 event->u.LoadDll.fUnicode = data.load_dll.unicode;
119 case UNLOAD_DLL_DEBUG_EVENT:
120 event->u.UnloadDll.lpBaseOfDll = wine_server_get_ptr( data.unload_dll.base );
122 case OUTPUT_DEBUG_STRING_EVENT:
123 event->u.DebugString.lpDebugStringData = wine_server_get_ptr( data.output_string.string );
124 event->u.DebugString.fUnicode = FALSE;
125 event->u.DebugString.nDebugStringLength = data.output_string.length;
128 event->u.RipInfo.dwError = data.rip_info.error;
129 event->u.RipInfo.dwType = data.rip_info.type;
136 if (ret) return TRUE;
138 res = WaitForSingleObject( wait, timeout );
140 if (res != STATUS_WAIT_0) break;
142 SetLastError( ERROR_SEM_TIMEOUT );
147 /**********************************************************************
148 * ContinueDebugEvent (KERNEL32.@)
150 * Enables a thread that previously produced a debug event to continue.
153 * pid [I] The id of the process to continue.
154 * tid [I] The id of the thread to continue.
155 * status [I] The rule to apply to unhandled exeptions.
159 * True if the debugger is listed as the processes owner and the process
160 * and thread are valid.
162 BOOL WINAPI ContinueDebugEvent(
168 SERVER_START_REQ( continue_debug_event )
172 req->status = status;
173 ret = !wine_server_call_err( req );
180 /**********************************************************************
181 * DebugActiveProcess (KERNEL32.@)
183 * Attempts to attach the debugger to a process.
186 * pid [I] The process to be debugged.
190 * True if the debugger was attached to process.
192 BOOL WINAPI DebugActiveProcess( DWORD pid )
195 SERVER_START_REQ( debug_process )
199 ret = !wine_server_call_err( req );
205 /**********************************************************************
206 * DebugActiveProcessStop (KERNEL32.@)
208 * Attempts to detach the debugger from a process.
211 * pid [I] The process to be detached.
215 * True if the debugger was detached from the process.
217 BOOL WINAPI DebugActiveProcessStop( DWORD pid )
220 SERVER_START_REQ( debug_process )
224 ret = !wine_server_call_err( req );
231 /***********************************************************************
232 * OutputDebugStringA (KERNEL32.@)
234 * Output by an application of an ascii string to a debugger (if attached)
238 * str [I] The message to be logged and given to the debugger.
244 void WINAPI OutputDebugStringA( LPCSTR str )
246 static HANDLE DBWinMutex = NULL;
247 static BOOL mutex_inited = FALSE;
251 /* send string to attached debugger */
252 SERVER_START_REQ( output_debug_string )
254 req->string = wine_server_client_ptr( str );
255 req->length = strlen(str) + 1;
256 wine_server_call( req );
260 WARN("%s\n", debugstr_a(str));
262 /* send string to a system-wide monitor */
263 /* FIXME should only send to monitor if no debuggers are attached */
267 /* first call to OutputDebugString, initialize mutex handle */
268 static const WCHAR mutexname[] = {'D','B','W','i','n','M','u','t','e','x',0};
269 HANDLE mutex = CreateMutexExW( NULL, mutexname, 0, SYNCHRONIZE );
272 if (InterlockedCompareExchangePointer( &DBWinMutex, mutex, 0 ) != 0)
274 /* someone beat us here... */
275 CloseHandle( mutex );
283 static const WCHAR shmname[] = {'D','B','W','I','N','_','B','U','F','F','E','R',0};
284 static const WCHAR eventbuffername[] = {'D','B','W','I','N','_','B','U','F','F','E','R','_','R','E','A','D','Y',0};
285 static const WCHAR eventdataname[] = {'D','B','W','I','N','_','D','A','T','A','_','R','E','A','D','Y',0};
288 mapping = OpenFileMappingW( FILE_MAP_WRITE, FALSE, shmname );
292 HANDLE eventbuffer, eventdata;
294 buffer = MapViewOfFile( mapping, FILE_MAP_WRITE, 0, 0, 0 );
295 eventbuffer = OpenEventW( SYNCHRONIZE, FALSE, eventbuffername );
296 eventdata = OpenEventW( EVENT_MODIFY_STATE, FALSE, eventdataname );
298 if (buffer && eventbuffer && eventdata)
300 /* monitor is present, synchronize with other OutputDebugString invocations */
301 WaitForSingleObject( DBWinMutex, INFINITE );
303 /* acquire control over the buffer */
304 if (WaitForSingleObject( eventbuffer, 10000 ) == WAIT_OBJECT_0)
307 struct _mon_buffer_t {
310 } *mon_buffer = (struct _mon_buffer_t*) buffer;
312 str_len = strlen( str );
313 if (str_len > (4096 - sizeof(DWORD) - 1))
314 str_len = 4096 - sizeof(DWORD) - 1;
316 mon_buffer->pid = GetCurrentProcessId();
317 memcpy( mon_buffer->buffer, str, str_len );
318 mon_buffer->buffer[str_len] = 0;
320 /* signal data ready */
321 SetEvent( eventdata );
323 ReleaseMutex( DBWinMutex );
327 UnmapViewOfFile( buffer );
329 CloseHandle( eventbuffer );
331 CloseHandle( eventdata );
332 CloseHandle( mapping );
338 /***********************************************************************
339 * OutputDebugStringW (KERNEL32.@)
341 * Output by an application of a unicode string to a debugger (if attached)
345 * str [I] The message to be logged and given to the debugger.
351 void WINAPI OutputDebugStringW( LPCWSTR str )
356 RtlInitUnicodeString( &strW, str );
357 if (!RtlUnicodeStringToAnsiString( &strA, &strW, TRUE ))
359 OutputDebugStringA( strA.Buffer );
360 RtlFreeAnsiString( &strA );
365 /***********************************************************************
366 * DebugBreak (KERNEL32.@)
368 * Raises an exception so that a debugger (if attached)
369 * can take some action.
371 #if defined(__i386__) || defined(__x86_64__)
372 __ASM_STDCALL_FUNC( DebugBreak, 0, "jmp " __ASM_NAME("DbgBreakPoint") )
374 void WINAPI DebugBreak(void)
380 /***********************************************************************
381 * DebugBreakProcess (KERNEL32.@)
383 * Raises an exception so that a debugger (if attached)
384 * can take some action. Same as DebugBreak, but applies to any process.
387 * hProc [I] Process to break into.
391 * True if successful.
393 BOOL WINAPI DebugBreakProcess(HANDLE hProc)
397 TRACE("(%p)\n", hProc);
399 SERVER_START_REQ( debug_break )
401 req->handle = wine_server_obj_handle( hProc );
402 ret = !wine_server_call_err( req );
403 self = ret && reply->self;
406 if (self) DbgBreakPoint();
411 /***********************************************************************
412 * IsDebuggerPresent (KERNEL32.@)
414 * Allows a process to determine if there is a debugger attached.
420 * True if there is a debugger attached.
422 BOOL WINAPI IsDebuggerPresent(void)
424 return NtCurrentTeb()->Peb->BeingDebugged;
427 /***********************************************************************
428 * CheckRemoteDebuggerPresent (KERNEL32.@)
430 * Allows a process to determine if there is a remote debugger
437 * TRUE because it is a stub.
439 BOOL WINAPI CheckRemoteDebuggerPresent(HANDLE process, PBOOL DebuggerPresent)
444 if(!process || !DebuggerPresent)
446 SetLastError(ERROR_INVALID_PARAMETER);
450 status = NtQueryInformationProcess(process, ProcessDebugPort, &port, sizeof(port), NULL);
451 if (status != STATUS_SUCCESS)
453 SetLastError(RtlNtStatusToDosError(status));
457 *DebuggerPresent = !!port;
461 /***********************************************************************
462 * DebugSetProcessKillOnExit (KERNEL32.@)
464 * Let a debugger decide whether a debuggee will be killed upon debugger
468 * kill [I] If set to true then kill the process on exit.
471 * True if successful, false otherwise.
473 BOOL WINAPI DebugSetProcessKillOnExit(BOOL kill)
477 SERVER_START_REQ( set_debugger_kill_on_exit )
479 req->kill_on_exit = kill;
480 ret = !wine_server_call_err( req );