Added YUV routines needed for v4l driver, and in the future possibly
[wine/gsoc-2012-control.git] / dlls / kernel / debugger.c
blob45900997f79090b1d6dfa8c328acf34fb58f5601
1 /*
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include <stdio.h>
22 #include <string.h>
24 #include "winerror.h"
25 #include "wine/winbase16.h"
26 #include "wine/server.h"
27 #include "ntstatus.h"
28 #include "kernel_private.h"
29 #include "kernel16_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.
41 * PARAMS
42 * event [O] Address of structure for event information.
43 * timeout [I] Number of milliseconds to wait for event.
45 * RETURNS
47 * Returns true if a debug event occurred and false if the call timed out.
49 BOOL WINAPI WaitForDebugEvent(
50 LPDEBUG_EVENT event,
51 DWORD timeout)
53 BOOL ret;
54 DWORD res;
56 for (;;)
58 HANDLE wait = 0;
59 debug_event_t data;
60 SERVER_START_REQ( wait_debug_event )
62 req->get_handle = (timeout != 0);
63 wine_server_set_reply( req, &data, sizeof(data) );
64 if (!(ret = !wine_server_call_err( req ))) goto done;
66 if (!wine_server_reply_size(reply)) /* timeout */
68 wait = reply->wait;
69 ret = FALSE;
70 goto done;
72 event->dwDebugEventCode = data.code;
73 event->dwProcessId = (DWORD)reply->pid;
74 event->dwThreadId = (DWORD)reply->tid;
75 switch(data.code)
77 case EXCEPTION_DEBUG_EVENT:
78 event->u.Exception.ExceptionRecord = data.info.exception.record;
79 event->u.Exception.dwFirstChance = data.info.exception.first;
80 break;
81 case CREATE_THREAD_DEBUG_EVENT:
82 event->u.CreateThread.hThread = data.info.create_thread.handle;
83 event->u.CreateThread.lpThreadLocalBase = data.info.create_thread.teb;
84 event->u.CreateThread.lpStartAddress = data.info.create_thread.start;
85 break;
86 case CREATE_PROCESS_DEBUG_EVENT:
87 event->u.CreateProcessInfo.hFile = data.info.create_process.file;
88 event->u.CreateProcessInfo.hProcess = data.info.create_process.process;
89 event->u.CreateProcessInfo.hThread = data.info.create_process.thread;
90 event->u.CreateProcessInfo.lpBaseOfImage = data.info.create_process.base;
91 event->u.CreateProcessInfo.dwDebugInfoFileOffset = data.info.create_process.dbg_offset;
92 event->u.CreateProcessInfo.nDebugInfoSize = data.info.create_process.dbg_size;
93 event->u.CreateProcessInfo.lpThreadLocalBase = data.info.create_process.teb;
94 event->u.CreateProcessInfo.lpStartAddress = data.info.create_process.start;
95 event->u.CreateProcessInfo.lpImageName = data.info.create_process.name;
96 event->u.CreateProcessInfo.fUnicode = data.info.create_process.unicode;
97 break;
98 case EXIT_THREAD_DEBUG_EVENT:
99 event->u.ExitThread.dwExitCode = data.info.exit.exit_code;
100 break;
101 case EXIT_PROCESS_DEBUG_EVENT:
102 event->u.ExitProcess.dwExitCode = data.info.exit.exit_code;
103 break;
104 case LOAD_DLL_DEBUG_EVENT:
105 event->u.LoadDll.hFile = data.info.load_dll.handle;
106 event->u.LoadDll.lpBaseOfDll = data.info.load_dll.base;
107 event->u.LoadDll.dwDebugInfoFileOffset = data.info.load_dll.dbg_offset;
108 event->u.LoadDll.nDebugInfoSize = data.info.load_dll.dbg_size;
109 event->u.LoadDll.lpImageName = data.info.load_dll.name;
110 event->u.LoadDll.fUnicode = data.info.load_dll.unicode;
111 break;
112 case UNLOAD_DLL_DEBUG_EVENT:
113 event->u.UnloadDll.lpBaseOfDll = data.info.unload_dll.base;
114 break;
115 case OUTPUT_DEBUG_STRING_EVENT:
116 event->u.DebugString.lpDebugStringData = data.info.output_string.string;
117 event->u.DebugString.fUnicode = data.info.output_string.unicode;
118 event->u.DebugString.nDebugStringLength = data.info.output_string.length;
119 break;
120 case RIP_EVENT:
121 event->u.RipInfo.dwError = data.info.rip_info.error;
122 event->u.RipInfo.dwType = data.info.rip_info.type;
123 break;
125 done:
126 /* nothing */ ;
128 SERVER_END_REQ;
129 if (ret) return TRUE;
130 if (!wait) break;
131 res = WaitForSingleObject( wait, timeout );
132 CloseHandle( wait );
133 if (res != STATUS_WAIT_0) break;
135 SetLastError( ERROR_SEM_TIMEOUT );
136 return FALSE;
140 /**********************************************************************
141 * ContinueDebugEvent (KERNEL32.@)
143 * Enables a thread that previously produced a debug event to continue.
145 * PARAMS
146 * pid [I] The id of the process to continue.
147 * tid [I] The id of the thread to continue.
148 * status [I] The rule to apply to unhandled exeptions.
150 * RETURNS
152 * True if the debugger is listed as the processes owner and the process
153 * and thread are valid.
155 BOOL WINAPI ContinueDebugEvent(
156 DWORD pid,
157 DWORD tid,
158 DWORD status)
160 BOOL ret;
161 SERVER_START_REQ( continue_debug_event )
163 req->pid = pid;
164 req->tid = tid;
165 req->status = status;
166 ret = !wine_server_call_err( req );
168 SERVER_END_REQ;
169 return ret;
173 /**********************************************************************
174 * DebugActiveProcess (KERNEL32.@)
176 * Attempts to attach the debugger to a process.
178 * PARAMS
179 * pid [I] The process to be debugged.
181 * RETURNS
183 * True if the debugger was attached to process.
185 BOOL WINAPI DebugActiveProcess( DWORD pid )
187 BOOL ret;
188 SERVER_START_REQ( debug_process )
190 req->pid = pid;
191 req->attach = 1;
192 ret = !wine_server_call_err( req );
194 SERVER_END_REQ;
195 return ret;
198 /**********************************************************************
199 * DebugActiveProcessStop (KERNEL32.@)
201 * Attempts to detach the debugger from a process.
203 * PARAMS
204 * pid [I] The process to be detached.
206 * RETURNS
208 * True if the debugger was detached from the process.
210 BOOL WINAPI DebugActiveProcessStop( DWORD pid )
212 BOOL ret;
213 SERVER_START_REQ( debug_process )
215 req->pid = pid;
216 req->attach = 0;
217 ret = !wine_server_call_err( req );
219 SERVER_END_REQ;
220 return ret;
224 /***********************************************************************
225 * OutputDebugStringA (KERNEL32.@)
227 * Output by an application of an ascii string to a debugger (if attached)
228 * and program log.
230 * PARAMS
231 * str [I] The message to be logged and given to the debugger.
233 * RETURNS
235 * Nothing.
237 void WINAPI OutputDebugStringA( LPCSTR str )
239 SERVER_START_REQ( output_debug_string )
241 req->string = (void *)str;
242 req->unicode = 0;
243 req->length = strlen(str) + 1;
244 wine_server_call( req );
246 SERVER_END_REQ;
247 WARN("%s\n", str);
251 /***********************************************************************
252 * OutputDebugStringW (KERNEL32.@)
254 * Output by an application of a unicode string to a debugger (if attached)
255 * and program log.
257 * PARAMS
258 * str [I] The message to be logged and given to the debugger.
260 * RETURNS
262 * Nothing.
264 void WINAPI OutputDebugStringW( LPCWSTR str )
266 SERVER_START_REQ( output_debug_string )
268 req->string = (void *)str;
269 req->unicode = 1;
270 req->length = (lstrlenW(str) + 1) * sizeof(WCHAR);
271 wine_server_call( req );
273 SERVER_END_REQ;
274 WARN("%s\n", debugstr_w(str));
278 /***********************************************************************
279 * OutputDebugString (KERNEL.115)
281 * Output by a 16 bit application of an ascii string to a debugger (if attached)
282 * and program log.
284 * PARAMS
285 * str [I] The message to be logged and given to the debugger.
287 * RETURNS
289 void WINAPI OutputDebugString16( LPCSTR str )
291 OutputDebugStringA( str );
295 /***********************************************************************
296 * DebugBreak (KERNEL32.@)
298 * Raises an exception so that a debugger (if attached)
299 * can take some action.
301 * PARAMS
303 * RETURNS
305 void WINAPI DebugBreak(void)
307 DbgBreakPoint();
310 /***********************************************************************
311 * DebugBreakProcess (KERNEL32.@)
313 * Raises an exception so that a debugger (if attached)
314 * can take some action. Same as DebugBreak, but applies to any process.
316 * PARAMS
317 * hProc [I] Process to break into.
319 * RETURNS
321 * True if successful.
323 BOOL WINAPI DebugBreakProcess(HANDLE hProc)
325 BOOL ret, self;
327 TRACE("(%p)\n", hProc);
329 SERVER_START_REQ( debug_break )
331 req->handle = hProc;
332 ret = !wine_server_call_err( req );
333 self = ret && reply->self;
335 SERVER_END_REQ;
336 if (self) DbgBreakPoint();
337 return ret;
341 /***********************************************************************
342 * DebugBreak (KERNEL.203)
344 * Raises an expection in a 16 bit application so that a debugger (if attached)
345 * can take some action.
347 * PARAMS
349 * RETURNS
351 * BUGS
353 * Only 386 compatible processors implemented.
355 void WINAPI DebugBreak16(
356 CONTEXT86 *context) /* [in/out] A pointer to the 386 compatible processor state. */
358 #ifdef __i386__
359 EXCEPTION_RECORD rec;
361 rec.ExceptionCode = EXCEPTION_BREAKPOINT;
362 rec.ExceptionFlags = 0;
363 rec.ExceptionRecord = NULL;
364 rec.ExceptionAddress = (LPVOID)context->Eip;
365 rec.NumberParameters = 0;
366 NtRaiseException( &rec, context, TRUE );
367 #endif /* defined(__i386__) */
371 /***********************************************************************
372 * IsDebuggerPresent (KERNEL32.@)
374 * Allows a process to determine if there is a debugger attached.
376 * PARAMS
378 * RETURNS
380 * True if there is a debugger attached.
382 BOOL WINAPI IsDebuggerPresent(void)
384 return NtCurrentTeb()->Peb->BeingDebugged;
388 /***********************************************************************
389 * _DebugOutput (KERNEL.328)
391 void WINAPIV _DebugOutput( WORD flags, LPCSTR spec, VA_LIST16 valist )
393 char caller[101];
395 /* Decode caller address */
396 if (!GetModuleName16( GetExePtr(CURRENT_STACK16->cs), caller, sizeof(caller) ))
397 sprintf( caller, "%04X:%04X", CURRENT_STACK16->cs, CURRENT_STACK16->ip );
399 /* FIXME: cannot use wvsnprintf16 from kernel */
400 /* wvsnprintf16( temp, sizeof(temp), spec, valist ); */
402 /* Output */
403 FIXME("%s %04x %s\n", caller, flags, debugstr_a(spec) );
406 /***********************************************************************
407 * DebugSetProcessKillOnExit (KERNEL32.@)
409 * Let a debugger decide whether a debuggee will be killed upon debugger
410 * termination.
412 * PARAMS
413 * kill [I] If set to true then kill the process on exit.
415 * RETURNS
416 * True if successful, false otherwise.
418 BOOL WINAPI DebugSetProcessKillOnExit(BOOL kill)
420 BOOL ret = FALSE;
422 SERVER_START_REQ( set_debugger_kill_on_exit )
424 req->kill_on_exit = kill;
425 ret = !wine_server_call_err( req );
427 SERVER_END_REQ;
428 return ret;