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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "wine/port.h"
37 enum debug_event_state
{ EVENT_QUEUED
, EVENT_SENT
, EVENT_CONTINUED
};
42 struct object obj
; /* object header */
43 struct debug_event
*next
; /* event queue */
44 struct debug_event
*prev
;
45 struct thread
*sender
; /* thread which sent this event */
46 struct thread
*debugger
; /* debugger thread receiving the event */
47 enum debug_event_state state
; /* event state */
48 int status
; /* continuation status */
49 debug_event_t data
; /* event data */
50 CONTEXT context
; /* register context */
56 struct object obj
; /* object header */
57 struct debug_event
*event_head
; /* head of pending events queue */
58 struct debug_event
*event_tail
; /* tail of pending events queue */
59 int kill_on_exit
;/* kill debuggees on debugger exit ? */
63 static void debug_event_dump( struct object
*obj
, int verbose
);
64 static int debug_event_signaled( struct object
*obj
, struct thread
*thread
);
65 static void debug_event_destroy( struct object
*obj
);
67 static const struct object_ops debug_event_ops
=
69 sizeof(struct debug_event
), /* size */
70 debug_event_dump
, /* dump */
71 add_queue
, /* add_queue */
72 remove_queue
, /* remove_queue */
73 debug_event_signaled
, /* signaled */
74 no_satisfied
, /* satisfied */
75 no_get_fd
, /* get_fd */
76 debug_event_destroy
/* destroy */
79 static void debug_ctx_dump( struct object
*obj
, int verbose
);
80 static int debug_ctx_signaled( struct object
*obj
, struct thread
*thread
);
81 static void debug_ctx_destroy( struct object
*obj
);
83 static const struct object_ops debug_ctx_ops
=
85 sizeof(struct debug_ctx
), /* size */
86 debug_ctx_dump
, /* dump */
87 add_queue
, /* add_queue */
88 remove_queue
, /* remove_queue */
89 debug_ctx_signaled
, /* signaled */
90 no_satisfied
, /* satisfied */
91 no_get_fd
, /* get_fd */
92 debug_ctx_destroy
/* destroy */
96 /* routines to build an event according to its type */
98 static int fill_exception_event( struct debug_event
*event
, void *arg
)
100 memcpy( &event
->data
.info
.exception
, arg
, sizeof(event
->data
.info
.exception
) );
104 static int fill_create_thread_event( struct debug_event
*event
, void *arg
)
106 struct process
*debugger
= event
->debugger
->process
;
107 struct thread
*thread
= event
->sender
;
110 /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
111 if (!(handle
= alloc_handle( debugger
, thread
, THREAD_ALL_ACCESS
, FALSE
))) return 0;
112 event
->data
.info
.create_thread
.handle
= handle
;
113 event
->data
.info
.create_thread
.teb
= thread
->teb
;
114 event
->data
.info
.create_thread
.start
= arg
;
118 static int fill_create_process_event( struct debug_event
*event
, void *arg
)
120 struct process
*debugger
= event
->debugger
->process
;
121 struct thread
*thread
= event
->sender
;
122 struct process
*process
= thread
->process
;
125 /* documented: PROCESS_VM_READ | PROCESS_VM_WRITE */
126 if (!(handle
= alloc_handle( debugger
, process
, PROCESS_ALL_ACCESS
, FALSE
))) return 0;
127 event
->data
.info
.create_process
.process
= handle
;
129 /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
130 if (!(handle
= alloc_handle( debugger
, thread
, THREAD_ALL_ACCESS
, FALSE
)))
132 close_handle( debugger
, event
->data
.info
.create_process
.process
, NULL
);
135 event
->data
.info
.create_process
.thread
= handle
;
138 if (process
->exe
.file
&&
139 /* the doc says write access too, but this doesn't seem a good idea */
140 !(handle
= alloc_handle( debugger
, process
->exe
.file
, GENERIC_READ
, FALSE
)))
142 close_handle( debugger
, event
->data
.info
.create_process
.process
, NULL
);
143 close_handle( debugger
, event
->data
.info
.create_process
.thread
, NULL
);
146 event
->data
.info
.create_process
.file
= handle
;
147 event
->data
.info
.create_process
.teb
= thread
->teb
;
148 event
->data
.info
.create_process
.base
= process
->exe
.base
;
149 event
->data
.info
.create_process
.start
= arg
;
150 event
->data
.info
.create_process
.dbg_offset
= process
->exe
.dbg_offset
;
151 event
->data
.info
.create_process
.dbg_size
= process
->exe
.dbg_size
;
152 event
->data
.info
.create_process
.name
= process
->exe
.name
;
153 event
->data
.info
.create_process
.unicode
= 0;
157 static int fill_exit_thread_event( struct debug_event
*event
, void *arg
)
159 struct thread
*thread
= arg
;
160 event
->data
.info
.exit
.exit_code
= thread
->exit_code
;
164 static int fill_exit_process_event( struct debug_event
*event
, void *arg
)
166 struct process
*process
= arg
;
167 event
->data
.info
.exit
.exit_code
= process
->exit_code
;
171 static int fill_load_dll_event( struct debug_event
*event
, void *arg
)
173 struct process
*debugger
= event
->debugger
->process
;
174 struct process_dll
*dll
= arg
;
175 obj_handle_t handle
= 0;
177 if (dll
->file
&& !(handle
= alloc_handle( debugger
, dll
->file
, GENERIC_READ
, FALSE
)))
179 event
->data
.info
.load_dll
.handle
= handle
;
180 event
->data
.info
.load_dll
.base
= dll
->base
;
181 event
->data
.info
.load_dll
.dbg_offset
= dll
->dbg_offset
;
182 event
->data
.info
.load_dll
.dbg_size
= dll
->dbg_size
;
183 event
->data
.info
.load_dll
.name
= dll
->name
;
184 event
->data
.info
.load_dll
.unicode
= 0;
188 static int fill_unload_dll_event( struct debug_event
*event
, void *arg
)
190 event
->data
.info
.unload_dll
.base
= arg
;
194 static int fill_output_debug_string_event( struct debug_event
*event
, void *arg
)
196 struct debug_event_output_string
*data
= arg
;
197 event
->data
.info
.output_string
= *data
;
201 typedef int (*fill_event_func
)( struct debug_event
*event
, void *arg
);
203 #define NB_DEBUG_EVENTS OUTPUT_DEBUG_STRING_EVENT /* RIP_EVENT not supported */
205 static const fill_event_func fill_debug_event
[NB_DEBUG_EVENTS
] =
207 fill_exception_event
, /* EXCEPTION_DEBUG_EVENT */
208 fill_create_thread_event
, /* CREATE_THREAD_DEBUG_EVENT */
209 fill_create_process_event
, /* CREATE_PROCESS_DEBUG_EVENT */
210 fill_exit_thread_event
, /* EXIT_THREAD_DEBUG_EVENT */
211 fill_exit_process_event
, /* EXIT_PROCESS_DEBUG_EVENT */
212 fill_load_dll_event
, /* LOAD_DLL_DEBUG_EVENT */
213 fill_unload_dll_event
, /* UNLOAD_DLL_DEBUG_EVENT */
214 fill_output_debug_string_event
/* OUTPUT_DEBUG_STRING_EVENT */
218 /* unlink the first event from the queue */
219 static void unlink_event( struct debug_ctx
*debug_ctx
, struct debug_event
*event
)
221 if (event
->prev
) event
->prev
->next
= event
->next
;
222 else debug_ctx
->event_head
= event
->next
;
223 if (event
->next
) event
->next
->prev
= event
->prev
;
224 else debug_ctx
->event_tail
= event
->prev
;
225 event
->next
= event
->prev
= NULL
;
226 if (event
->sender
->debug_event
== event
) event
->sender
->debug_event
= NULL
;
227 release_object( event
);
230 /* link an event at the end of the queue */
231 static void link_event( struct debug_event
*event
)
233 struct debug_ctx
*debug_ctx
= event
->debugger
->debug_ctx
;
236 grab_object( event
);
238 event
->prev
= debug_ctx
->event_tail
;
239 debug_ctx
->event_tail
= event
;
240 if (event
->prev
) event
->prev
->next
= event
;
241 else debug_ctx
->event_head
= event
;
242 if (!event
->sender
->debug_event
) wake_up( &debug_ctx
->obj
, 0 );
245 /* find the next event that we can send to the debugger */
246 static struct debug_event
*find_event_to_send( struct debug_ctx
*debug_ctx
)
248 struct debug_event
*event
;
249 for (event
= debug_ctx
->event_head
; event
; event
= event
->next
)
251 if (event
->state
== EVENT_SENT
) continue; /* already sent */
252 if (event
->sender
->debug_event
) continue; /* thread busy with another one */
258 static void debug_event_dump( struct object
*obj
, int verbose
)
260 struct debug_event
*debug_event
= (struct debug_event
*)obj
;
261 assert( obj
->ops
== &debug_event_ops
);
262 fprintf( stderr
, "Debug event sender=%p code=%d state=%d\n",
263 debug_event
->sender
, debug_event
->data
.code
, debug_event
->state
);
266 static int debug_event_signaled( struct object
*obj
, struct thread
*thread
)
268 struct debug_event
*debug_event
= (struct debug_event
*)obj
;
269 assert( obj
->ops
== &debug_event_ops
);
270 return debug_event
->state
== EVENT_CONTINUED
;
273 static void debug_event_destroy( struct object
*obj
)
275 struct debug_event
*event
= (struct debug_event
*)obj
;
276 assert( obj
->ops
== &debug_event_ops
);
278 /* cannot still be in the queue */
279 assert( !event
->next
);
280 assert( !event
->prev
);
282 /* If the event has been sent already, the handles are now under the */
283 /* responsibility of the debugger process, so we don't touch them */
284 if (event
->state
== EVENT_QUEUED
)
286 struct process
*debugger
= event
->debugger
->process
;
287 switch(event
->data
.code
)
289 case CREATE_THREAD_DEBUG_EVENT
:
290 close_handle( debugger
, event
->data
.info
.create_thread
.handle
, NULL
);
292 case CREATE_PROCESS_DEBUG_EVENT
:
293 if (event
->data
.info
.create_process
.file
)
294 close_handle( debugger
, event
->data
.info
.create_process
.file
, NULL
);
295 close_handle( debugger
, event
->data
.info
.create_process
.thread
, NULL
);
296 close_handle( debugger
, event
->data
.info
.create_process
.process
, NULL
);
298 case LOAD_DLL_DEBUG_EVENT
:
299 if (event
->data
.info
.load_dll
.handle
)
300 close_handle( debugger
, event
->data
.info
.load_dll
.handle
, NULL
);
304 if (event
->sender
->context
== &event
->context
) event
->sender
->context
= NULL
;
305 release_object( event
->sender
);
306 release_object( event
->debugger
);
309 static void debug_ctx_dump( struct object
*obj
, int verbose
)
311 struct debug_ctx
*debug_ctx
= (struct debug_ctx
*)obj
;
312 assert( obj
->ops
== &debug_ctx_ops
);
313 fprintf( stderr
, "Debug context head=%p tail=%p\n",
314 debug_ctx
->event_head
, debug_ctx
->event_tail
);
317 static int debug_ctx_signaled( struct object
*obj
, struct thread
*thread
)
319 struct debug_ctx
*debug_ctx
= (struct debug_ctx
*)obj
;
320 assert( obj
->ops
== &debug_ctx_ops
);
321 return find_event_to_send( debug_ctx
) != NULL
;
324 static void debug_ctx_destroy( struct object
*obj
)
326 struct debug_event
*event
;
327 struct debug_ctx
*debug_ctx
= (struct debug_ctx
*)obj
;
328 assert( obj
->ops
== &debug_ctx_ops
);
330 /* free all pending events */
331 while ((event
= debug_ctx
->event_head
) != NULL
) unlink_event( debug_ctx
, event
);
334 /* continue a debug event */
335 static int continue_debug_event( struct process
*process
, struct thread
*thread
, int status
)
337 struct debug_event
*event
;
338 struct debug_ctx
*debug_ctx
= current
->debug_ctx
;
340 if (!debug_ctx
|| process
->debugger
!= current
|| thread
->process
!= process
) goto error
;
342 /* find the event in the queue */
343 for (event
= debug_ctx
->event_head
; event
; event
= event
->next
)
345 if (event
->state
!= EVENT_SENT
) continue;
346 if (event
->sender
== thread
) break;
348 if (!event
) goto error
;
350 assert( event
->sender
->debug_event
== event
);
352 event
->status
= status
;
353 event
->state
= EVENT_CONTINUED
;
354 wake_up( &event
->obj
, 0 );
356 unlink_event( debug_ctx
, event
);
357 resume_process( process
);
360 /* not debugging this process, or no such event */
361 set_error( STATUS_ACCESS_DENIED
); /* FIXME */
365 /* alloc a debug event for a debugger */
366 static struct debug_event
*alloc_debug_event( struct thread
*thread
, int code
,
367 void *arg
, const CONTEXT
*context
)
369 struct thread
*debugger
= thread
->process
->debugger
;
370 struct debug_event
*event
;
372 assert( code
> 0 && code
<= NB_DEBUG_EVENTS
);
373 /* cannot queue a debug event for myself */
374 assert( debugger
->process
!= thread
->process
);
376 /* build the event */
377 if (!(event
= alloc_object( &debug_event_ops
, -1 ))) return NULL
;
380 event
->state
= EVENT_QUEUED
;
381 event
->sender
= (struct thread
*)grab_object( thread
);
382 event
->debugger
= (struct thread
*)grab_object( debugger
);
383 event
->data
.code
= code
;
385 if (!fill_debug_event
[code
-1]( event
, arg
))
387 event
->data
.code
= -1; /* make sure we don't attempt to close handles */
388 release_object( event
);
393 memcpy( &event
->context
, context
, sizeof(event
->context
) );
394 thread
->context
= &event
->context
;
399 /* generate a debug event from inside the server and queue it */
400 void generate_debug_event( struct thread
*thread
, int code
, void *arg
)
402 if (thread
->process
->debugger
)
404 struct debug_event
*event
= alloc_debug_event( thread
, code
, arg
, NULL
);
408 suspend_process( thread
->process
);
409 release_object( event
);
414 /* attach a process to a debugger thread and suspend it */
415 static int debugger_attach( struct process
*process
, struct thread
*debugger
)
417 struct thread
*thread
;
419 if (process
->debugger
) goto error
; /* already being debugged */
420 if (!is_process_init_done( process
)) goto error
; /* still starting up */
421 if (!process
->thread_list
) goto error
; /* no thread running in the process */
423 /* make sure we don't create a debugging loop */
424 for (thread
= debugger
; thread
; thread
= thread
->process
->debugger
)
425 if (thread
->process
== process
) goto error
;
427 /* don't let a debugger debug its console... won't work */
428 if (debugger
->process
->console
&& debugger
->process
->console
->renderer
->process
== process
)
431 suspend_process( process
);
433 /* we must have been able to attach all threads */
434 if (!process
->thread_list
) goto error2
;
435 for (thread
= process
->thread_list
; thread
; thread
= thread
->proc_next
)
437 if (!thread
->attached
) goto error2
;
440 if (set_process_debugger( process
, debugger
)) return 1;
441 resume_process( process
);
445 resume_process( process
);
447 set_error( STATUS_ACCESS_DENIED
);
452 /* detach a process from a debugger thread (and resume it ?) */
453 int debugger_detach( struct process
*process
, struct thread
*debugger
)
455 struct thread
*thread
;
456 struct debug_event
*event
;
457 struct debug_ctx
*debug_ctx
;
459 if (!process
->debugger
|| process
->debugger
!= debugger
)
460 goto error
; /* not currently debugged, or debugged by another debugger */
461 if (!debugger
->debug_ctx
) goto error
; /* should be a debugger */
462 /* init should be done, otherwise wouldn't be attached */
463 assert(is_process_init_done(process
));
465 suspend_process( process
);
466 /* send continue indication for all events */
467 debug_ctx
= debugger
->debug_ctx
;
469 /* find the event in the queue
470 * FIXME: could loop on process' threads and look the debug_event field */
471 for (event
= debug_ctx
->event_head
; event
; event
= event
->next
)
473 if (event
->state
!= EVENT_QUEUED
) continue;
475 if (event
->sender
->process
== process
)
477 assert( event
->sender
->debug_event
== event
);
478 event
->status
= DBG_CONTINUE
;
479 event
->state
= EVENT_CONTINUED
;
480 wake_up( &event
->obj
, 0 );
481 unlink_event( debug_ctx
, event
);
482 /* from queued debug event */
483 resume_process( process
);
487 /* remove relationships between process and its debugger */
488 process
->debugger
= NULL
;
489 release_object( debugger
->debug_ctx
);
490 debugger
->debug_ctx
= NULL
;
492 /* now detach all the threads */
493 for (thread
= process
->thread_list
; thread
; thread
= thread
->proc_next
)
495 if (thread
->attached
)
497 detach_thread( thread
, 0 );
501 /* from this function */
502 resume_process( process
);
506 set_error( STATUS_ACCESS_DENIED
);
510 /* generate all startup events of a given process */
511 void generate_startup_debug_events( struct process
*process
, void *entry
)
513 struct process_dll
*dll
;
514 struct thread
*thread
= process
->thread_list
;
516 /* generate creation events */
517 generate_debug_event( thread
, CREATE_PROCESS_DEBUG_EVENT
, entry
);
518 while ((thread
= thread
->proc_next
))
519 generate_debug_event( thread
, CREATE_THREAD_DEBUG_EVENT
, NULL
);
521 /* generate dll events (in loading order, i.e. reverse list order) */
523 while (dll
->next
) dll
= dll
->next
;
524 while (dll
!= &process
->exe
)
526 generate_debug_event( process
->thread_list
, LOAD_DLL_DEBUG_EVENT
, dll
);
531 /* set the debugger of a given process */
532 int set_process_debugger( struct process
*process
, struct thread
*debugger
)
534 struct debug_ctx
*debug_ctx
;
536 assert( !process
->debugger
);
538 if (!debugger
->debug_ctx
) /* need to allocate a context */
540 if (!(debug_ctx
= alloc_object( &debug_ctx_ops
, -1 ))) return 0;
541 debug_ctx
->event_head
= NULL
;
542 debug_ctx
->event_tail
= NULL
;
543 debug_ctx
->kill_on_exit
= 1;
544 debugger
->debug_ctx
= debug_ctx
;
546 process
->debugger
= debugger
;
550 /* a thread is exiting */
551 void debug_exit_thread( struct thread
*thread
)
553 if (thread
->debug_ctx
) /* this thread is a debugger */
555 if (thread
->debug_ctx
->kill_on_exit
)
557 /* kill all debugged processes */
558 kill_debugged_processes( thread
, thread
->exit_code
);
562 detach_debugged_processes( thread
);
564 release_object( thread
->debug_ctx
);
565 thread
->debug_ctx
= NULL
;
569 /* Wait for a debug event */
570 DECL_HANDLER(wait_debug_event
)
572 struct debug_ctx
*debug_ctx
= current
->debug_ctx
;
573 struct debug_event
*event
;
575 if (!debug_ctx
) /* current thread is not a debugger */
577 set_error( STATUS_INVALID_HANDLE
);
581 if ((event
= find_event_to_send( debug_ctx
)))
583 size_t size
= get_reply_max_size();
584 event
->state
= EVENT_SENT
;
585 event
->sender
->debug_event
= event
;
586 reply
->pid
= get_process_id( event
->sender
->process
);
587 reply
->tid
= get_thread_id( event
->sender
);
588 if (size
> sizeof(debug_event_t
)) size
= sizeof(debug_event_t
);
589 set_reply_data( &event
->data
, size
);
591 else /* no event ready */
596 reply
->wait
= alloc_handle( current
->process
, debug_ctx
, SYNCHRONIZE
, FALSE
);
600 /* Continue a debug event */
601 DECL_HANDLER(continue_debug_event
)
603 struct process
*process
= get_process_from_id( req
->pid
);
606 struct thread
*thread
= get_thread_from_id( req
->tid
);
609 continue_debug_event( process
, thread
, req
->status
);
610 release_object( thread
);
612 release_object( process
);
616 /* Start debugging an existing process */
617 DECL_HANDLER(debug_process
)
619 struct process
*process
= get_process_from_id( req
->pid
);
620 if (!process
) return;
624 debugger_detach( process
, current
);
626 else if (debugger_attach( process
, current
))
628 struct debug_event_exception data
;
630 generate_startup_debug_events( process
, NULL
);
631 resume_process( process
);
633 data
.record
.ExceptionCode
= EXCEPTION_BREAKPOINT
;
634 data
.record
.ExceptionFlags
= EXCEPTION_CONTINUABLE
;
635 data
.record
.ExceptionRecord
= NULL
;
636 data
.record
.ExceptionAddress
= get_thread_ip( process
->thread_list
);
637 data
.record
.NumberParameters
= 0;
639 generate_debug_event( process
->thread_list
, EXCEPTION_DEBUG_EVENT
, &data
);
641 release_object( process
);
644 /* queue an exception event */
645 DECL_HANDLER(queue_exception_event
)
648 if (current
->process
->debugger
)
650 struct debug_event_exception data
;
651 struct debug_event
*event
;
652 const CONTEXT
*context
= get_req_data();
653 EXCEPTION_RECORD
*rec
= (EXCEPTION_RECORD
*)(context
+ 1);
655 if (get_req_data_size() < sizeof(*rec
) + sizeof(*context
))
657 set_error( STATUS_INVALID_PARAMETER
);
661 data
.first
= req
->first
;
662 if ((event
= alloc_debug_event( current
, EXCEPTION_DEBUG_EVENT
, &data
, context
)))
664 if ((reply
->handle
= alloc_handle( current
->process
, event
, SYNCHRONIZE
, FALSE
)))
667 suspend_process( current
->process
);
669 release_object( event
);
674 /* retrieve the status of an exception event */
675 DECL_HANDLER(get_exception_status
)
677 struct debug_event
*event
;
680 if ((event
= (struct debug_event
*)get_handle_obj( current
->process
, req
->handle
,
681 0, &debug_event_ops
)))
683 if (event
->state
== EVENT_CONTINUED
)
685 reply
->status
= event
->status
;
686 if (current
->context
== &event
->context
)
688 size_t size
= min( sizeof(CONTEXT
), get_reply_max_size() );
689 set_reply_data( &event
->context
, size
);
690 current
->context
= NULL
;
693 else set_error( STATUS_PENDING
);
694 release_object( event
);
698 /* send an output string to the debugger */
699 DECL_HANDLER(output_debug_string
)
701 struct debug_event_output_string data
;
703 data
.string
= req
->string
;
704 data
.unicode
= req
->unicode
;
705 data
.length
= req
->length
;
706 generate_debug_event( current
, OUTPUT_DEBUG_STRING_EVENT
, &data
);
709 /* simulate a breakpoint in a process */
710 DECL_HANDLER(debug_break
)
712 struct process
*process
;
715 if (!(process
= get_process_from_handle( req
->handle
, PROCESS_SET_INFORMATION
/*FIXME*/ )))
717 if (process
!= current
->process
)
719 /* find a suitable thread to signal */
720 struct thread
*thread
;
721 for (thread
= process
->thread_list
; thread
; thread
= thread
->proc_next
)
723 if (thread
->unix_pid
)
725 kill( thread
->unix_pid
, SIGTRAP
);
729 if (!thread
) set_error( STATUS_ACCESS_DENIED
);
731 else reply
->self
= 1;
732 release_object( process
);
735 /* set debugger kill on exit flag */
736 DECL_HANDLER(set_debugger_kill_on_exit
)
738 if (!current
->debug_ctx
)
740 set_error( STATUS_ACCESS_DENIED
);
743 current
->debug_ctx
->kill_on_exit
= req
->kill_on_exit
;