d3dx8: Fix number of parameter of functions D3DXVec4Cross and D3DXVec?CatmullRom.
[wine/multimedia.git] / server / debugger.c
bloba64a17a7d8956931acc4a5f72f297f17c7db7d76
1 /*
2 * Server-side 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
21 #include "config.h"
22 #include "wine/port.h"
24 #include <assert.h>
25 #include <signal.h>
26 #include <string.h>
27 #include <stdarg.h>
28 #include <stdio.h>
30 #include "ntstatus.h"
31 #define WIN32_NO_STATUS
32 #include "windef.h"
33 #include "winternl.h"
35 #include "handle.h"
36 #include "process.h"
37 #include "thread.h"
38 #include "request.h"
40 enum debug_event_state { EVENT_QUEUED, EVENT_SENT, EVENT_CONTINUED };
42 /* debug event */
43 struct debug_event
45 struct object obj; /* object header */
46 struct list entry; /* entry in event queue */
47 struct thread *sender; /* thread which sent this event */
48 struct thread *debugger; /* debugger thread receiving the event */
49 enum debug_event_state state; /* event state */
50 int status; /* continuation status */
51 debug_event_t data; /* event data */
52 CONTEXT context; /* register context */
55 /* debug context */
56 struct debug_ctx
58 struct object obj; /* object header */
59 struct list event_queue; /* pending events queue */
60 int kill_on_exit;/* kill debuggees on debugger exit ? */
64 static void debug_event_dump( struct object *obj, int verbose );
65 static int debug_event_signaled( struct object *obj, struct thread *thread );
66 static void debug_event_destroy( struct object *obj );
68 static const struct object_ops debug_event_ops =
70 sizeof(struct debug_event), /* size */
71 debug_event_dump, /* dump */
72 add_queue, /* add_queue */
73 remove_queue, /* remove_queue */
74 debug_event_signaled, /* signaled */
75 no_satisfied, /* satisfied */
76 no_signal, /* signal */
77 no_get_fd, /* get_fd */
78 no_map_access, /* map_access */
79 default_get_sd, /* get_sd */
80 default_set_sd, /* set_sd */
81 no_lookup_name, /* lookup_name */
82 no_open_file, /* open_file */
83 no_close_handle, /* close_handle */
84 debug_event_destroy /* destroy */
87 static void debug_ctx_dump( struct object *obj, int verbose );
88 static int debug_ctx_signaled( struct object *obj, struct thread *thread );
89 static void debug_ctx_destroy( struct object *obj );
91 static const struct object_ops debug_ctx_ops =
93 sizeof(struct debug_ctx), /* size */
94 debug_ctx_dump, /* dump */
95 add_queue, /* add_queue */
96 remove_queue, /* remove_queue */
97 debug_ctx_signaled, /* signaled */
98 no_satisfied, /* satisfied */
99 no_signal, /* signal */
100 no_get_fd, /* get_fd */
101 no_map_access, /* map_access */
102 default_get_sd, /* get_sd */
103 default_set_sd, /* set_sd */
104 no_lookup_name, /* lookup_name */
105 no_open_file, /* open_file */
106 no_close_handle, /* close_handle */
107 debug_ctx_destroy /* destroy */
111 /* routines to build an event according to its type */
113 static int fill_exception_event( struct debug_event *event, void *arg )
115 memcpy( &event->data.info.exception, arg, sizeof(event->data.info.exception) );
116 return 1;
119 static int fill_create_thread_event( struct debug_event *event, void *arg )
121 struct process *debugger = event->debugger->process;
122 struct thread *thread = event->sender;
123 obj_handle_t handle;
125 /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
126 if (!(handle = alloc_handle( debugger, thread, THREAD_ALL_ACCESS, 0 ))) return 0;
127 event->data.info.create_thread.handle = handle;
128 event->data.info.create_thread.teb = thread->teb;
129 event->data.info.create_thread.start = arg;
130 return 1;
133 static int fill_create_process_event( struct debug_event *event, void *arg )
135 struct process *debugger = event->debugger->process;
136 struct thread *thread = event->sender;
137 struct process *process = thread->process;
138 struct process_dll *exe_module = get_process_exe_module( process );
139 obj_handle_t handle;
141 /* documented: PROCESS_VM_READ | PROCESS_VM_WRITE */
142 if (!(handle = alloc_handle( debugger, process, PROCESS_ALL_ACCESS, 0 ))) return 0;
143 event->data.info.create_process.process = handle;
145 /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
146 if (!(handle = alloc_handle( debugger, thread, THREAD_ALL_ACCESS, 0 )))
148 close_handle( debugger, event->data.info.create_process.process );
149 return 0;
151 event->data.info.create_process.thread = handle;
153 handle = 0;
154 if (exe_module->file &&
155 /* the doc says write access too, but this doesn't seem a good idea */
156 !(handle = alloc_handle( debugger, exe_module->file, GENERIC_READ, 0 )))
158 close_handle( debugger, event->data.info.create_process.process );
159 close_handle( debugger, event->data.info.create_process.thread );
160 return 0;
162 event->data.info.create_process.file = handle;
163 event->data.info.create_process.teb = thread->teb;
164 event->data.info.create_process.base = exe_module->base;
165 event->data.info.create_process.start = arg;
166 event->data.info.create_process.dbg_offset = exe_module->dbg_offset;
167 event->data.info.create_process.dbg_size = exe_module->dbg_size;
168 event->data.info.create_process.name = exe_module->name;
169 event->data.info.create_process.unicode = 1;
170 return 1;
173 static int fill_exit_thread_event( struct debug_event *event, void *arg )
175 struct thread *thread = arg;
176 event->data.info.exit.exit_code = thread->exit_code;
177 return 1;
180 static int fill_exit_process_event( struct debug_event *event, void *arg )
182 struct process *process = arg;
183 event->data.info.exit.exit_code = process->exit_code;
184 return 1;
187 static int fill_load_dll_event( struct debug_event *event, void *arg )
189 struct process *debugger = event->debugger->process;
190 struct process_dll *dll = arg;
191 obj_handle_t handle = 0;
193 if (dll->file && !(handle = alloc_handle( debugger, dll->file, GENERIC_READ, 0 )))
194 return 0;
195 event->data.info.load_dll.handle = handle;
196 event->data.info.load_dll.base = dll->base;
197 event->data.info.load_dll.dbg_offset = dll->dbg_offset;
198 event->data.info.load_dll.dbg_size = dll->dbg_size;
199 event->data.info.load_dll.name = dll->name;
200 event->data.info.load_dll.unicode = 1;
201 return 1;
204 static int fill_unload_dll_event( struct debug_event *event, void *arg )
206 event->data.info.unload_dll.base = arg;
207 return 1;
210 static int fill_output_debug_string_event( struct debug_event *event, void *arg )
212 struct debug_event_output_string *data = arg;
213 event->data.info.output_string = *data;
214 return 1;
217 typedef int (*fill_event_func)( struct debug_event *event, void *arg );
219 #define NB_DEBUG_EVENTS OUTPUT_DEBUG_STRING_EVENT /* RIP_EVENT not supported */
221 static const fill_event_func fill_debug_event[NB_DEBUG_EVENTS] =
223 fill_exception_event, /* EXCEPTION_DEBUG_EVENT */
224 fill_create_thread_event, /* CREATE_THREAD_DEBUG_EVENT */
225 fill_create_process_event, /* CREATE_PROCESS_DEBUG_EVENT */
226 fill_exit_thread_event, /* EXIT_THREAD_DEBUG_EVENT */
227 fill_exit_process_event, /* EXIT_PROCESS_DEBUG_EVENT */
228 fill_load_dll_event, /* LOAD_DLL_DEBUG_EVENT */
229 fill_unload_dll_event, /* UNLOAD_DLL_DEBUG_EVENT */
230 fill_output_debug_string_event /* OUTPUT_DEBUG_STRING_EVENT */
234 /* unlink the first event from the queue */
235 static void unlink_event( struct debug_ctx *debug_ctx, struct debug_event *event )
237 list_remove( &event->entry );
238 if (event->sender->debug_event == event) event->sender->debug_event = NULL;
239 release_object( event );
242 /* link an event at the end of the queue */
243 static void link_event( struct debug_event *event )
245 struct debug_ctx *debug_ctx = event->debugger->debug_ctx;
247 assert( debug_ctx );
248 grab_object( event );
249 list_add_tail( &debug_ctx->event_queue, &event->entry );
250 if (!event->sender->debug_event) wake_up( &debug_ctx->obj, 0 );
253 /* find the next event that we can send to the debugger */
254 static struct debug_event *find_event_to_send( struct debug_ctx *debug_ctx )
256 struct debug_event *event;
258 LIST_FOR_EACH_ENTRY( event, &debug_ctx->event_queue, struct debug_event, entry )
260 if (event->state == EVENT_SENT) continue; /* already sent */
261 if (event->sender->debug_event) continue; /* thread busy with another one */
262 return event;
264 return NULL;
267 static void debug_event_dump( struct object *obj, int verbose )
269 struct debug_event *debug_event = (struct debug_event *)obj;
270 assert( obj->ops == &debug_event_ops );
271 fprintf( stderr, "Debug event sender=%p code=%d state=%d\n",
272 debug_event->sender, debug_event->data.code, debug_event->state );
275 static int debug_event_signaled( struct object *obj, struct thread *thread )
277 struct debug_event *debug_event = (struct debug_event *)obj;
278 assert( obj->ops == &debug_event_ops );
279 return debug_event->state == EVENT_CONTINUED;
282 static void debug_event_destroy( struct object *obj )
284 struct debug_event *event = (struct debug_event *)obj;
285 assert( obj->ops == &debug_event_ops );
287 /* If the event has been sent already, the handles are now under the */
288 /* responsibility of the debugger process, so we don't touch them */
289 if (event->state == EVENT_QUEUED)
291 struct process *debugger = event->debugger->process;
292 switch(event->data.code)
294 case CREATE_THREAD_DEBUG_EVENT:
295 close_handle( debugger, event->data.info.create_thread.handle );
296 break;
297 case CREATE_PROCESS_DEBUG_EVENT:
298 if (event->data.info.create_process.file)
299 close_handle( debugger, event->data.info.create_process.file );
300 close_handle( debugger, event->data.info.create_process.thread );
301 close_handle( debugger, event->data.info.create_process.process );
302 break;
303 case LOAD_DLL_DEBUG_EVENT:
304 if (event->data.info.load_dll.handle)
305 close_handle( debugger, event->data.info.load_dll.handle );
306 break;
309 if (event->sender->context == &event->context) event->sender->context = NULL;
310 release_object( event->sender );
311 release_object( event->debugger );
314 static void debug_ctx_dump( struct object *obj, int verbose )
316 struct debug_ctx *debug_ctx = (struct debug_ctx *)obj;
317 assert( obj->ops == &debug_ctx_ops );
318 fprintf( stderr, "Debug context head=%p tail=%p\n",
319 debug_ctx->event_queue.next, debug_ctx->event_queue.prev );
322 static int debug_ctx_signaled( struct object *obj, struct thread *thread )
324 struct debug_ctx *debug_ctx = (struct debug_ctx *)obj;
325 assert( obj->ops == &debug_ctx_ops );
326 return find_event_to_send( debug_ctx ) != NULL;
329 static void debug_ctx_destroy( struct object *obj )
331 struct list *ptr;
332 struct debug_ctx *debug_ctx = (struct debug_ctx *)obj;
333 assert( obj->ops == &debug_ctx_ops );
335 /* free all pending events */
336 while ((ptr = list_head( &debug_ctx->event_queue )))
337 unlink_event( debug_ctx, LIST_ENTRY( ptr, struct debug_event, entry ));
340 /* continue a debug event */
341 static int continue_debug_event( struct process *process, struct thread *thread, int status )
343 struct debug_ctx *debug_ctx = current->debug_ctx;
345 if (debug_ctx && process->debugger == current && thread->process == process)
347 struct debug_event *event;
349 /* find the event in the queue */
350 LIST_FOR_EACH_ENTRY( event, &debug_ctx->event_queue, struct debug_event, entry )
352 if (event->state != EVENT_SENT) continue;
353 if (event->sender == thread)
355 assert( event->sender->debug_event == event );
357 event->status = status;
358 event->state = EVENT_CONTINUED;
359 wake_up( &event->obj, 0 );
360 unlink_event( debug_ctx, event );
361 resume_process( process );
362 return 1;
366 /* not debugging this process, or no such event */
367 set_error( STATUS_ACCESS_DENIED ); /* FIXME */
368 return 0;
371 /* alloc a debug event for a debugger */
372 static struct debug_event *alloc_debug_event( struct thread *thread, int code,
373 void *arg, const CONTEXT *context )
375 struct thread *debugger = thread->process->debugger;
376 struct debug_event *event;
378 assert( code > 0 && code <= NB_DEBUG_EVENTS );
379 /* cannot queue a debug event for myself */
380 assert( debugger->process != thread->process );
382 /* build the event */
383 if (!(event = alloc_object( &debug_event_ops ))) return NULL;
384 event->state = EVENT_QUEUED;
385 event->sender = (struct thread *)grab_object( thread );
386 event->debugger = (struct thread *)grab_object( debugger );
387 event->data.code = code;
389 if (!fill_debug_event[code-1]( event, arg ))
391 event->data.code = -1; /* make sure we don't attempt to close handles */
392 release_object( event );
393 return NULL;
395 if (context)
397 memcpy( &event->context, context, sizeof(event->context) );
398 thread->context = &event->context;
400 return event;
403 /* generate a debug event from inside the server and queue it */
404 void generate_debug_event( struct thread *thread, int code, void *arg )
406 if (thread->process->debugger)
408 struct debug_event *event = alloc_debug_event( thread, code, arg, NULL );
409 if (event)
411 link_event( event );
412 suspend_process( thread->process );
413 release_object( event );
418 /* attach a process to a debugger thread and suspend it */
419 static int debugger_attach( struct process *process, struct thread *debugger )
421 struct thread *thread;
423 if (process->debugger) goto error; /* already being debugged */
424 if (!is_process_init_done( process )) goto error; /* still starting up */
425 if (list_empty( &process->thread_list )) goto error; /* no thread running in the process */
427 /* make sure we don't create a debugging loop */
428 for (thread = debugger; thread; thread = thread->process->debugger)
429 if (thread->process == process) goto error;
431 /* don't let a debugger debug its console... won't work */
432 if (debugger->process->console && console_get_renderer(debugger->process->console)->process == process)
433 goto error;
435 suspend_process( process );
436 if (!set_process_debugger( process, debugger ))
438 resume_process( process );
439 return 0;
441 if (!set_process_debug_flag( process, 1 ))
443 process->debugger = NULL;
444 resume_process( process );
445 return 0;
447 return 1;
449 error:
450 set_error( STATUS_ACCESS_DENIED );
451 return 0;
455 /* detach a process from a debugger thread (and resume it ?) */
456 int debugger_detach( struct process *process, struct thread *debugger )
458 struct debug_event *event, *next;
459 struct debug_ctx *debug_ctx;
461 if (!process->debugger || process->debugger != debugger)
462 goto error; /* not currently debugged, or debugged by another debugger */
463 if (!debugger->debug_ctx ) goto error; /* should be a debugger */
464 /* init should be done, otherwise wouldn't be attached */
465 assert(is_process_init_done(process));
467 suspend_process( process );
468 /* send continue indication for all events */
469 debug_ctx = debugger->debug_ctx;
471 /* free all events from this process */
472 LIST_FOR_EACH_ENTRY_SAFE( event, next, &debug_ctx->event_queue, struct debug_event, entry )
474 if (event->sender->process != process) continue;
476 assert( event->state != EVENT_CONTINUED );
477 event->status = DBG_CONTINUE;
478 event->state = EVENT_CONTINUED;
479 wake_up( &event->obj, 0 );
480 unlink_event( debug_ctx, event );
481 /* from queued debug event */
482 resume_process( process );
485 /* remove relationships between process and its debugger */
486 process->debugger = NULL;
487 if (!set_process_debug_flag( process, 0 )) clear_error(); /* ignore error */
489 /* from this function */
490 resume_process( process );
491 return 0;
493 error:
494 set_error( STATUS_ACCESS_DENIED );
495 return 0;
498 /* generate all startup events of a given process */
499 void generate_startup_debug_events( struct process *process, void *entry )
501 struct list *ptr;
502 struct thread *thread, *first_thread = get_process_first_thread( process );
504 /* generate creation events */
505 LIST_FOR_EACH_ENTRY( thread, &process->thread_list, struct thread, proc_entry )
507 if (thread == first_thread)
508 generate_debug_event( thread, CREATE_PROCESS_DEBUG_EVENT, entry );
509 else
510 generate_debug_event( thread, CREATE_THREAD_DEBUG_EVENT, NULL );
513 /* generate dll events (in loading order, i.e. reverse list order) */
514 ptr = list_tail( &process->dlls );
515 while (ptr)
517 struct process_dll *dll = LIST_ENTRY( ptr, struct process_dll, entry );
518 generate_debug_event( first_thread, LOAD_DLL_DEBUG_EVENT, dll );
519 ptr = list_prev( &process->dlls, ptr );
523 /* set the debugger of a given process */
524 int set_process_debugger( struct process *process, struct thread *debugger )
526 struct debug_ctx *debug_ctx;
528 assert( !process->debugger );
530 if (!debugger->debug_ctx) /* need to allocate a context */
532 if (!(debug_ctx = alloc_object( &debug_ctx_ops ))) return 0;
533 debug_ctx->kill_on_exit = 1;
534 list_init( &debug_ctx->event_queue );
535 debugger->debug_ctx = debug_ctx;
537 process->debugger = debugger;
538 return 1;
541 /* a thread is exiting */
542 void debug_exit_thread( struct thread *thread )
544 if (thread->debug_ctx) /* this thread is a debugger */
546 if (thread->debug_ctx->kill_on_exit)
548 /* kill all debugged processes */
549 kill_debugged_processes( thread, STATUS_DEBUGGER_INACTIVE );
551 else
553 detach_debugged_processes( thread );
555 release_object( thread->debug_ctx );
556 thread->debug_ctx = NULL;
560 /* Wait for a debug event */
561 DECL_HANDLER(wait_debug_event)
563 struct debug_ctx *debug_ctx = current->debug_ctx;
564 struct debug_event *event;
566 if (!debug_ctx) /* current thread is not a debugger */
568 set_error( STATUS_INVALID_HANDLE );
569 return;
571 reply->wait = 0;
572 if ((event = find_event_to_send( debug_ctx )))
574 data_size_t size = get_reply_max_size();
575 event->state = EVENT_SENT;
576 event->sender->debug_event = event;
577 reply->pid = get_process_id( event->sender->process );
578 reply->tid = get_thread_id( event->sender );
579 if (size > sizeof(debug_event_t)) size = sizeof(debug_event_t);
580 set_reply_data( &event->data, size );
582 else /* no event ready */
584 reply->pid = 0;
585 reply->tid = 0;
586 if (req->get_handle)
587 reply->wait = alloc_handle( current->process, debug_ctx, SYNCHRONIZE, 0 );
591 /* Continue a debug event */
592 DECL_HANDLER(continue_debug_event)
594 struct process *process = get_process_from_id( req->pid );
595 if (process)
597 struct thread *thread = get_thread_from_id( req->tid );
598 if (thread)
600 continue_debug_event( process, thread, req->status );
601 release_object( thread );
603 release_object( process );
607 /* Start debugging an existing process */
608 DECL_HANDLER(debug_process)
610 struct process *process = get_process_from_id( req->pid );
611 if (!process) return;
613 if (!req->attach)
615 debugger_detach( process, current );
617 else if (debugger_attach( process, current ))
619 generate_startup_debug_events( process, NULL );
620 break_process( process );
621 resume_process( process );
623 release_object( process );
626 /* queue an exception event */
627 DECL_HANDLER(queue_exception_event)
629 reply->handle = 0;
630 if (current->process->debugger)
632 struct debug_event_exception data;
633 struct debug_event *event;
634 const CONTEXT *context = get_req_data();
635 const EXCEPTION_RECORD *rec = (const EXCEPTION_RECORD *)(context + 1);
637 if (get_req_data_size() < sizeof(*rec) + sizeof(*context))
639 set_error( STATUS_INVALID_PARAMETER );
640 return;
642 data.record = *rec;
643 data.first = req->first;
644 if ((event = alloc_debug_event( current, EXCEPTION_DEBUG_EVENT, &data, context )))
646 if ((reply->handle = alloc_handle( current->process, event, SYNCHRONIZE, 0 )))
648 link_event( event );
649 suspend_process( current->process );
651 release_object( event );
656 /* retrieve the status of an exception event */
657 DECL_HANDLER(get_exception_status)
659 struct debug_event *event;
661 if ((event = (struct debug_event *)get_handle_obj( current->process, req->handle,
662 0, &debug_event_ops )))
664 close_handle( current->process, req->handle );
665 if (event->state == EVENT_CONTINUED)
667 if (current->context == &event->context)
669 data_size_t size = min( sizeof(CONTEXT), get_reply_max_size() );
670 set_reply_data( &event->context, size );
671 current->context = NULL;
673 set_error( event->status );
675 else set_error( STATUS_PENDING );
676 release_object( event );
680 /* send an output string to the debugger */
681 DECL_HANDLER(output_debug_string)
683 struct debug_event_output_string data;
685 data.string = req->string;
686 data.unicode = req->unicode;
687 data.length = req->length;
688 generate_debug_event( current, OUTPUT_DEBUG_STRING_EVENT, &data );
691 /* simulate a breakpoint in a process */
692 DECL_HANDLER(debug_break)
694 struct process *process;
696 reply->self = 0;
697 if ((process = get_process_from_handle( req->handle, PROCESS_SET_INFORMATION /*FIXME*/ )))
699 if (process != current->process) break_process( process );
700 else reply->self = 1;
701 release_object( process );
705 /* set debugger kill on exit flag */
706 DECL_HANDLER(set_debugger_kill_on_exit)
708 if (!current->debug_ctx)
710 set_error( STATUS_ACCESS_DENIED );
711 return;
713 current->debug_ctx->kill_on_exit = req->kill_on_exit;