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
22 #include "wine/port.h"
31 #define WIN32_NO_STATUS
40 enum debug_event_state
{ EVENT_QUEUED
, EVENT_SENT
, EVENT_CONTINUED
};
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 */
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 no_get_type
, /* get_type */
73 add_queue
, /* add_queue */
74 remove_queue
, /* remove_queue */
75 debug_event_signaled
, /* signaled */
76 no_satisfied
, /* satisfied */
77 no_signal
, /* signal */
78 no_get_fd
, /* get_fd */
79 no_map_access
, /* map_access */
80 default_get_sd
, /* get_sd */
81 default_set_sd
, /* set_sd */
82 no_lookup_name
, /* lookup_name */
83 no_open_file
, /* open_file */
84 no_close_handle
, /* close_handle */
85 debug_event_destroy
/* destroy */
88 static void debug_ctx_dump( struct object
*obj
, int verbose
);
89 static int debug_ctx_signaled( struct object
*obj
, struct thread
*thread
);
90 static void debug_ctx_destroy( struct object
*obj
);
92 static const struct object_ops debug_ctx_ops
=
94 sizeof(struct debug_ctx
), /* size */
95 debug_ctx_dump
, /* dump */
96 no_get_type
, /* get_type */
97 add_queue
, /* add_queue */
98 remove_queue
, /* remove_queue */
99 debug_ctx_signaled
, /* signaled */
100 no_satisfied
, /* satisfied */
101 no_signal
, /* signal */
102 no_get_fd
, /* get_fd */
103 no_map_access
, /* map_access */
104 default_get_sd
, /* get_sd */
105 default_set_sd
, /* set_sd */
106 no_lookup_name
, /* lookup_name */
107 no_open_file
, /* open_file */
108 no_close_handle
, /* close_handle */
109 debug_ctx_destroy
/* destroy */
113 /* routines to build an event according to its type */
115 static int fill_exception_event( struct debug_event
*event
, void *arg
)
117 memcpy( &event
->data
.info
.exception
, arg
, sizeof(event
->data
.info
.exception
) );
121 static int fill_create_thread_event( struct debug_event
*event
, void *arg
)
123 struct process
*debugger
= event
->debugger
->process
;
124 struct thread
*thread
= event
->sender
;
127 /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
128 if (!(handle
= alloc_handle( debugger
, thread
, THREAD_ALL_ACCESS
, 0 ))) return 0;
129 event
->data
.info
.create_thread
.handle
= handle
;
130 event
->data
.info
.create_thread
.teb
= thread
->teb
;
131 event
->data
.info
.create_thread
.start
= arg
;
135 static int fill_create_process_event( struct debug_event
*event
, void *arg
)
137 struct process
*debugger
= event
->debugger
->process
;
138 struct thread
*thread
= event
->sender
;
139 struct process
*process
= thread
->process
;
140 struct process_dll
*exe_module
= get_process_exe_module( process
);
143 /* documented: PROCESS_VM_READ | PROCESS_VM_WRITE */
144 if (!(handle
= alloc_handle( debugger
, process
, PROCESS_ALL_ACCESS
, 0 ))) return 0;
145 event
->data
.info
.create_process
.process
= handle
;
147 /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
148 if (!(handle
= alloc_handle( debugger
, thread
, THREAD_ALL_ACCESS
, 0 )))
150 close_handle( debugger
, event
->data
.info
.create_process
.process
);
153 event
->data
.info
.create_process
.thread
= handle
;
156 if (exe_module
->file
&&
157 /* the doc says write access too, but this doesn't seem a good idea */
158 !(handle
= alloc_handle( debugger
, exe_module
->file
, GENERIC_READ
, 0 )))
160 close_handle( debugger
, event
->data
.info
.create_process
.process
);
161 close_handle( debugger
, event
->data
.info
.create_process
.thread
);
164 event
->data
.info
.create_process
.file
= handle
;
165 event
->data
.info
.create_process
.teb
= thread
->teb
;
166 event
->data
.info
.create_process
.base
= exe_module
->base
;
167 event
->data
.info
.create_process
.start
= arg
;
168 event
->data
.info
.create_process
.dbg_offset
= exe_module
->dbg_offset
;
169 event
->data
.info
.create_process
.dbg_size
= exe_module
->dbg_size
;
170 event
->data
.info
.create_process
.name
= exe_module
->name
;
171 event
->data
.info
.create_process
.unicode
= 1;
175 static int fill_exit_thread_event( struct debug_event
*event
, void *arg
)
177 struct thread
*thread
= arg
;
178 event
->data
.info
.exit
.exit_code
= thread
->exit_code
;
182 static int fill_exit_process_event( struct debug_event
*event
, void *arg
)
184 struct process
*process
= arg
;
185 event
->data
.info
.exit
.exit_code
= process
->exit_code
;
189 static int fill_load_dll_event( struct debug_event
*event
, void *arg
)
191 struct process
*debugger
= event
->debugger
->process
;
192 struct process_dll
*dll
= arg
;
193 obj_handle_t handle
= 0;
195 if (dll
->file
&& !(handle
= alloc_handle( debugger
, dll
->file
, GENERIC_READ
, 0 )))
197 event
->data
.info
.load_dll
.handle
= handle
;
198 event
->data
.info
.load_dll
.base
= dll
->base
;
199 event
->data
.info
.load_dll
.dbg_offset
= dll
->dbg_offset
;
200 event
->data
.info
.load_dll
.dbg_size
= dll
->dbg_size
;
201 event
->data
.info
.load_dll
.name
= dll
->name
;
202 event
->data
.info
.load_dll
.unicode
= 1;
206 static int fill_unload_dll_event( struct debug_event
*event
, void *arg
)
208 mod_handle_t
*base
= arg
;
209 event
->data
.info
.unload_dll
.base
= *base
;
213 static int fill_output_debug_string_event( struct debug_event
*event
, void *arg
)
215 struct debug_event_output_string
*data
= arg
;
216 event
->data
.info
.output_string
= *data
;
220 typedef int (*fill_event_func
)( struct debug_event
*event
, void *arg
);
222 #define NB_DEBUG_EVENTS OUTPUT_DEBUG_STRING_EVENT /* RIP_EVENT not supported */
224 static const fill_event_func fill_debug_event
[NB_DEBUG_EVENTS
] =
226 fill_exception_event
, /* EXCEPTION_DEBUG_EVENT */
227 fill_create_thread_event
, /* CREATE_THREAD_DEBUG_EVENT */
228 fill_create_process_event
, /* CREATE_PROCESS_DEBUG_EVENT */
229 fill_exit_thread_event
, /* EXIT_THREAD_DEBUG_EVENT */
230 fill_exit_process_event
, /* EXIT_PROCESS_DEBUG_EVENT */
231 fill_load_dll_event
, /* LOAD_DLL_DEBUG_EVENT */
232 fill_unload_dll_event
, /* UNLOAD_DLL_DEBUG_EVENT */
233 fill_output_debug_string_event
/* OUTPUT_DEBUG_STRING_EVENT */
237 /* unlink the first event from the queue */
238 static void unlink_event( struct debug_ctx
*debug_ctx
, struct debug_event
*event
)
240 list_remove( &event
->entry
);
241 if (event
->sender
->debug_event
== event
) event
->sender
->debug_event
= NULL
;
242 release_object( event
);
245 /* link an event at the end of the queue */
246 static void link_event( struct debug_event
*event
)
248 struct debug_ctx
*debug_ctx
= event
->debugger
->debug_ctx
;
251 grab_object( event
);
252 list_add_tail( &debug_ctx
->event_queue
, &event
->entry
);
253 if (!event
->sender
->debug_event
) wake_up( &debug_ctx
->obj
, 0 );
256 /* find the next event that we can send to the debugger */
257 static struct debug_event
*find_event_to_send( struct debug_ctx
*debug_ctx
)
259 struct debug_event
*event
;
261 LIST_FOR_EACH_ENTRY( event
, &debug_ctx
->event_queue
, struct debug_event
, entry
)
263 if (event
->state
== EVENT_SENT
) continue; /* already sent */
264 if (event
->sender
->debug_event
) continue; /* thread busy with another one */
270 static void debug_event_dump( struct object
*obj
, int verbose
)
272 struct debug_event
*debug_event
= (struct debug_event
*)obj
;
273 assert( obj
->ops
== &debug_event_ops
);
274 fprintf( stderr
, "Debug event sender=%p code=%d state=%d\n",
275 debug_event
->sender
, debug_event
->data
.code
, debug_event
->state
);
278 static int debug_event_signaled( struct object
*obj
, struct thread
*thread
)
280 struct debug_event
*debug_event
= (struct debug_event
*)obj
;
281 assert( obj
->ops
== &debug_event_ops
);
282 return debug_event
->state
== EVENT_CONTINUED
;
285 static void debug_event_destroy( struct object
*obj
)
287 struct debug_event
*event
= (struct debug_event
*)obj
;
288 assert( obj
->ops
== &debug_event_ops
);
290 /* If the event has been sent already, the handles are now under the */
291 /* responsibility of the debugger process, so we don't touch them */
292 if (event
->state
== EVENT_QUEUED
)
294 struct process
*debugger
= event
->debugger
->process
;
295 switch(event
->data
.code
)
297 case CREATE_THREAD_DEBUG_EVENT
:
298 close_handle( debugger
, event
->data
.info
.create_thread
.handle
);
300 case CREATE_PROCESS_DEBUG_EVENT
:
301 if (event
->data
.info
.create_process
.file
)
302 close_handle( debugger
, event
->data
.info
.create_process
.file
);
303 close_handle( debugger
, event
->data
.info
.create_process
.thread
);
304 close_handle( debugger
, event
->data
.info
.create_process
.process
);
306 case LOAD_DLL_DEBUG_EVENT
:
307 if (event
->data
.info
.load_dll
.handle
)
308 close_handle( debugger
, event
->data
.info
.load_dll
.handle
);
312 if (event
->sender
->context
== &event
->context
) event
->sender
->context
= NULL
;
313 release_object( event
->sender
);
314 release_object( event
->debugger
);
317 static void debug_ctx_dump( struct object
*obj
, int verbose
)
319 struct debug_ctx
*debug_ctx
= (struct debug_ctx
*)obj
;
320 assert( obj
->ops
== &debug_ctx_ops
);
321 fprintf( stderr
, "Debug context head=%p tail=%p\n",
322 debug_ctx
->event_queue
.next
, debug_ctx
->event_queue
.prev
);
325 static int debug_ctx_signaled( struct object
*obj
, struct thread
*thread
)
327 struct debug_ctx
*debug_ctx
= (struct debug_ctx
*)obj
;
328 assert( obj
->ops
== &debug_ctx_ops
);
329 return find_event_to_send( debug_ctx
) != NULL
;
332 static void debug_ctx_destroy( struct object
*obj
)
335 struct debug_ctx
*debug_ctx
= (struct debug_ctx
*)obj
;
336 assert( obj
->ops
== &debug_ctx_ops
);
338 /* free all pending events */
339 while ((ptr
= list_head( &debug_ctx
->event_queue
)))
340 unlink_event( debug_ctx
, LIST_ENTRY( ptr
, struct debug_event
, entry
));
343 /* continue a debug event */
344 static int continue_debug_event( struct process
*process
, struct thread
*thread
, int status
)
346 struct debug_ctx
*debug_ctx
= current
->debug_ctx
;
348 if (debug_ctx
&& process
->debugger
== current
&& thread
->process
== process
)
350 struct debug_event
*event
;
352 /* find the event in the queue */
353 LIST_FOR_EACH_ENTRY( event
, &debug_ctx
->event_queue
, struct debug_event
, entry
)
355 if (event
->state
!= EVENT_SENT
) continue;
356 if (event
->sender
== thread
)
358 assert( event
->sender
->debug_event
== event
);
360 event
->status
= status
;
361 event
->state
= EVENT_CONTINUED
;
362 wake_up( &event
->obj
, 0 );
363 unlink_event( debug_ctx
, event
);
364 resume_process( process
);
369 /* not debugging this process, or no such event */
370 set_error( STATUS_ACCESS_DENIED
); /* FIXME */
374 /* alloc a debug event for a debugger */
375 static struct debug_event
*alloc_debug_event( struct thread
*thread
, int code
,
376 void *arg
, const CONTEXT
*context
)
378 struct thread
*debugger
= thread
->process
->debugger
;
379 struct debug_event
*event
;
381 assert( code
> 0 && code
<= NB_DEBUG_EVENTS
);
382 /* cannot queue a debug event for myself */
383 assert( debugger
->process
!= thread
->process
);
385 /* build the event */
386 if (!(event
= alloc_object( &debug_event_ops
))) return NULL
;
387 event
->state
= EVENT_QUEUED
;
388 event
->sender
= (struct thread
*)grab_object( thread
);
389 event
->debugger
= (struct thread
*)grab_object( debugger
);
390 event
->data
.code
= code
;
392 if (!fill_debug_event
[code
-1]( event
, arg
))
394 event
->data
.code
= -1; /* make sure we don't attempt to close handles */
395 release_object( event
);
400 memcpy( &event
->context
, context
, sizeof(event
->context
) );
401 thread
->context
= &event
->context
;
406 /* generate a debug event from inside the server and queue it */
407 void generate_debug_event( struct thread
*thread
, int code
, void *arg
)
409 if (thread
->process
->debugger
)
411 struct debug_event
*event
= alloc_debug_event( thread
, code
, arg
, NULL
);
415 suspend_process( thread
->process
);
416 release_object( event
);
421 /* attach a process to a debugger thread and suspend it */
422 static int debugger_attach( struct process
*process
, struct thread
*debugger
)
424 struct thread
*thread
;
426 if (process
->debugger
) goto error
; /* already being debugged */
427 if (!is_process_init_done( process
)) goto error
; /* still starting up */
428 if (list_empty( &process
->thread_list
)) goto error
; /* no thread running in the process */
430 /* make sure we don't create a debugging loop */
431 for (thread
= debugger
; thread
; thread
= thread
->process
->debugger
)
432 if (thread
->process
== process
) goto error
;
434 /* don't let a debugger debug its console... won't work */
435 if (debugger
->process
->console
&& console_get_renderer(debugger
->process
->console
)->process
== process
)
438 suspend_process( process
);
439 if (!set_process_debugger( process
, debugger
))
441 resume_process( process
);
444 if (!set_process_debug_flag( process
, 1 ))
446 process
->debugger
= NULL
;
447 resume_process( process
);
453 set_error( STATUS_ACCESS_DENIED
);
458 /* detach a process from a debugger thread (and resume it ?) */
459 int debugger_detach( struct process
*process
, struct thread
*debugger
)
461 struct debug_event
*event
, *next
;
462 struct debug_ctx
*debug_ctx
;
464 if (!process
->debugger
|| process
->debugger
!= debugger
)
465 goto error
; /* not currently debugged, or debugged by another debugger */
466 if (!debugger
->debug_ctx
) goto error
; /* should be a debugger */
467 /* init should be done, otherwise wouldn't be attached */
468 assert(is_process_init_done(process
));
470 suspend_process( process
);
471 /* send continue indication for all events */
472 debug_ctx
= debugger
->debug_ctx
;
474 /* free all events from this process */
475 LIST_FOR_EACH_ENTRY_SAFE( event
, next
, &debug_ctx
->event_queue
, struct debug_event
, entry
)
477 if (event
->sender
->process
!= process
) continue;
479 assert( event
->state
!= EVENT_CONTINUED
);
480 event
->status
= DBG_CONTINUE
;
481 event
->state
= EVENT_CONTINUED
;
482 wake_up( &event
->obj
, 0 );
483 unlink_event( debug_ctx
, event
);
484 /* from queued debug event */
485 resume_process( process
);
488 /* remove relationships between process and its debugger */
489 process
->debugger
= NULL
;
490 if (!set_process_debug_flag( process
, 0 )) clear_error(); /* ignore error */
492 /* from this function */
493 resume_process( process
);
497 set_error( STATUS_ACCESS_DENIED
);
501 /* generate all startup events of a given process */
502 void generate_startup_debug_events( struct process
*process
, void *entry
)
505 struct thread
*thread
, *first_thread
= get_process_first_thread( process
);
507 /* generate creation events */
508 LIST_FOR_EACH_ENTRY( thread
, &process
->thread_list
, struct thread
, proc_entry
)
510 if (thread
== first_thread
)
511 generate_debug_event( thread
, CREATE_PROCESS_DEBUG_EVENT
, entry
);
513 generate_debug_event( thread
, CREATE_THREAD_DEBUG_EVENT
, NULL
);
516 /* generate dll events (in loading order, i.e. reverse list order) */
517 ptr
= list_tail( &process
->dlls
);
520 struct process_dll
*dll
= LIST_ENTRY( ptr
, struct process_dll
, entry
);
521 generate_debug_event( first_thread
, LOAD_DLL_DEBUG_EVENT
, dll
);
522 ptr
= list_prev( &process
->dlls
, ptr
);
526 /* set the debugger of a given process */
527 int set_process_debugger( struct process
*process
, struct thread
*debugger
)
529 struct debug_ctx
*debug_ctx
;
531 assert( !process
->debugger
);
533 if (!debugger
->debug_ctx
) /* need to allocate a context */
535 if (!(debug_ctx
= alloc_object( &debug_ctx_ops
))) return 0;
536 debug_ctx
->kill_on_exit
= 1;
537 list_init( &debug_ctx
->event_queue
);
538 debugger
->debug_ctx
= debug_ctx
;
540 process
->debugger
= debugger
;
544 /* a thread is exiting */
545 void debug_exit_thread( struct thread
*thread
)
547 if (thread
->debug_ctx
) /* this thread is a debugger */
549 if (thread
->debug_ctx
->kill_on_exit
)
551 /* kill all debugged processes */
552 kill_debugged_processes( thread
, STATUS_DEBUGGER_INACTIVE
);
556 detach_debugged_processes( thread
);
558 release_object( thread
->debug_ctx
);
559 thread
->debug_ctx
= NULL
;
563 /* Wait for a debug event */
564 DECL_HANDLER(wait_debug_event
)
566 struct debug_ctx
*debug_ctx
= current
->debug_ctx
;
567 struct debug_event
*event
;
569 if (!debug_ctx
) /* current thread is not a debugger */
571 set_error( STATUS_INVALID_HANDLE
);
575 if ((event
= find_event_to_send( debug_ctx
)))
577 data_size_t size
= get_reply_max_size();
578 event
->state
= EVENT_SENT
;
579 event
->sender
->debug_event
= event
;
580 reply
->pid
= get_process_id( event
->sender
->process
);
581 reply
->tid
= get_thread_id( event
->sender
);
582 if (size
> sizeof(debug_event_t
)) size
= sizeof(debug_event_t
);
583 set_reply_data( &event
->data
, size
);
585 else /* no event ready */
590 reply
->wait
= alloc_handle( current
->process
, debug_ctx
, SYNCHRONIZE
, 0 );
594 /* Continue a debug event */
595 DECL_HANDLER(continue_debug_event
)
597 struct process
*process
= get_process_from_id( req
->pid
);
600 struct thread
*thread
= get_thread_from_id( req
->tid
);
603 continue_debug_event( process
, thread
, req
->status
);
604 release_object( thread
);
606 release_object( process
);
610 /* Start debugging an existing process */
611 DECL_HANDLER(debug_process
)
613 struct process
*process
= get_process_from_id( req
->pid
);
614 if (!process
) return;
618 debugger_detach( process
, current
);
620 else if (debugger_attach( process
, current
))
622 generate_startup_debug_events( process
, NULL
);
623 break_process( process
);
624 resume_process( process
);
626 release_object( process
);
629 /* queue an exception event */
630 DECL_HANDLER(queue_exception_event
)
633 if (current
->process
->debugger
)
635 struct debug_event_exception data
;
636 struct debug_event
*event
;
637 const CONTEXT
*context
= get_req_data();
638 const EXCEPTION_RECORD
*rec
= (const EXCEPTION_RECORD
*)(context
+ 1);
640 if (get_req_data_size() < sizeof(*rec
) + sizeof(*context
))
642 set_error( STATUS_INVALID_PARAMETER
);
646 data
.first
= req
->first
;
647 if ((event
= alloc_debug_event( current
, EXCEPTION_DEBUG_EVENT
, &data
, context
)))
649 if ((reply
->handle
= alloc_handle( current
->process
, event
, SYNCHRONIZE
, 0 )))
652 suspend_process( current
->process
);
654 release_object( event
);
659 /* retrieve the status of an exception event */
660 DECL_HANDLER(get_exception_status
)
662 struct debug_event
*event
;
664 if ((event
= (struct debug_event
*)get_handle_obj( current
->process
, req
->handle
,
665 0, &debug_event_ops
)))
667 close_handle( current
->process
, req
->handle
);
668 if (event
->state
== EVENT_CONTINUED
)
670 if (current
->context
== &event
->context
)
672 data_size_t size
= min( sizeof(CONTEXT
), get_reply_max_size() );
673 set_reply_data( &event
->context
, size
);
674 current
->context
= NULL
;
676 set_error( event
->status
);
678 else set_error( STATUS_PENDING
);
679 release_object( event
);
683 /* send an output string to the debugger */
684 DECL_HANDLER(output_debug_string
)
686 struct debug_event_output_string data
;
688 data
.string
= req
->string
;
689 data
.unicode
= req
->unicode
;
690 data
.length
= req
->length
;
691 generate_debug_event( current
, OUTPUT_DEBUG_STRING_EVENT
, &data
);
694 /* simulate a breakpoint in a process */
695 DECL_HANDLER(debug_break
)
697 struct process
*process
;
700 if ((process
= get_process_from_handle( req
->handle
, PROCESS_SET_INFORMATION
/*FIXME*/ )))
702 if (process
!= current
->process
) break_process( process
);
703 else reply
->self
= 1;
704 release_object( process
);
708 /* set debugger kill on exit flag */
709 DECL_HANDLER(set_debugger_kill_on_exit
)
711 if (!current
->debug_ctx
)
713 set_error( STATUS_ACCESS_DENIED
);
716 current
->debug_ctx
->kill_on_exit
= req
->kill_on_exit
;