2 * Server-side debugger functions
4 * Copyright (C) 1999 Alexandre Julliard
18 enum debug_event_state
{ EVENT_QUEUED
, EVENT_SENT
, EVENT_CONTINUED
};
23 struct object obj
; /* object header */
24 struct debug_event
*next
; /* event queue */
25 struct debug_event
*prev
;
26 struct thread
*sender
; /* thread which sent this event */
27 struct thread
*debugger
; /* debugger thread receiving the event */
28 enum debug_event_state state
; /* event state */
29 int status
; /* continuation status */
30 debug_event_t data
; /* event data */
36 struct object obj
; /* object header */
37 struct debug_event
*event_head
; /* head of pending events queue */
38 struct debug_event
*event_tail
; /* tail of pending events queue */
42 static void debug_event_dump( struct object
*obj
, int verbose
);
43 static int debug_event_signaled( struct object
*obj
, struct thread
*thread
);
44 static void debug_event_destroy( struct object
*obj
);
46 static const struct object_ops debug_event_ops
=
48 sizeof(struct debug_event
), /* size */
49 debug_event_dump
, /* dump */
50 add_queue
, /* add_queue */
51 remove_queue
, /* remove_queue */
52 debug_event_signaled
, /* signaled */
53 no_satisfied
, /* satisfied */
54 NULL
, /* get_poll_events */
55 NULL
, /* poll_event */
56 no_get_fd
, /* get_fd */
58 no_get_file_info
, /* get_file_info */
59 debug_event_destroy
/* destroy */
62 static void debug_ctx_dump( struct object
*obj
, int verbose
);
63 static int debug_ctx_signaled( struct object
*obj
, struct thread
*thread
);
64 static void debug_ctx_destroy( struct object
*obj
);
66 static const struct object_ops debug_ctx_ops
=
68 sizeof(struct debug_ctx
), /* size */
69 debug_ctx_dump
, /* dump */
70 add_queue
, /* add_queue */
71 remove_queue
, /* remove_queue */
72 debug_ctx_signaled
, /* signaled */
73 no_satisfied
, /* satisfied */
74 NULL
, /* get_poll_events */
75 NULL
, /* poll_event */
76 no_get_fd
, /* get_fd */
78 no_get_file_info
, /* get_file_info */
79 debug_ctx_destroy
/* destroy */
83 /* routines to build an event according to its type */
85 static int fill_exception_event( struct debug_event
*event
, void *arg
)
87 memcpy( &event
->data
.info
.exception
, arg
, sizeof(event
->data
.info
.exception
) );
91 static int fill_create_thread_event( struct debug_event
*event
, void *arg
)
93 struct process
*debugger
= event
->debugger
->process
;
94 struct thread
*thread
= event
->sender
;
97 /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
98 if (!(handle
= alloc_handle( debugger
, thread
, THREAD_ALL_ACCESS
, FALSE
))) return 0;
99 event
->data
.info
.create_thread
.handle
= handle
;
100 event
->data
.info
.create_thread
.teb
= thread
->teb
;
101 event
->data
.info
.create_thread
.start
= arg
;
105 static int fill_create_process_event( struct debug_event
*event
, void *arg
)
107 struct process
*debugger
= event
->debugger
->process
;
108 struct thread
*thread
= event
->sender
;
109 struct process
*process
= thread
->process
;
112 /* documented: PROCESS_VM_READ | PROCESS_VM_WRITE */
113 if (!(handle
= alloc_handle( debugger
, process
, PROCESS_ALL_ACCESS
, FALSE
))) return 0;
114 event
->data
.info
.create_process
.process
= handle
;
116 /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
117 if (!(handle
= alloc_handle( debugger
, thread
, THREAD_ALL_ACCESS
, FALSE
)))
119 close_handle( debugger
, event
->data
.info
.create_process
.process
, NULL
);
122 event
->data
.info
.create_process
.thread
= handle
;
125 if (process
->exe
.file
&&
126 /* the doc says write access too, but this doesn't seem a good idea */
127 !(handle
= alloc_handle( debugger
, process
->exe
.file
, GENERIC_READ
, FALSE
)))
129 close_handle( debugger
, event
->data
.info
.create_process
.process
, NULL
);
130 close_handle( debugger
, event
->data
.info
.create_process
.thread
, NULL
);
133 event
->data
.info
.create_process
.file
= handle
;
134 event
->data
.info
.create_process
.teb
= thread
->teb
;
135 event
->data
.info
.create_process
.base
= process
->exe
.base
;
136 event
->data
.info
.create_process
.start
= arg
;
137 event
->data
.info
.create_process
.dbg_offset
= process
->exe
.dbg_offset
;
138 event
->data
.info
.create_process
.dbg_size
= process
->exe
.dbg_size
;
139 event
->data
.info
.create_process
.name
= process
->exe
.name
;
140 event
->data
.info
.create_process
.unicode
= 0;
144 static int fill_exit_thread_event( struct debug_event
*event
, void *arg
)
146 struct thread
*thread
= arg
;
147 event
->data
.info
.exit
.exit_code
= thread
->exit_code
;
151 static int fill_exit_process_event( struct debug_event
*event
, void *arg
)
153 struct process
*process
= arg
;
154 event
->data
.info
.exit
.exit_code
= process
->exit_code
;
158 static int fill_load_dll_event( struct debug_event
*event
, void *arg
)
160 struct process
*debugger
= event
->debugger
->process
;
161 struct process_dll
*dll
= arg
;
164 if (dll
->file
&& !(handle
= alloc_handle( debugger
, dll
->file
, GENERIC_READ
, FALSE
)))
166 event
->data
.info
.load_dll
.handle
= handle
;
167 event
->data
.info
.load_dll
.base
= dll
->base
;
168 event
->data
.info
.load_dll
.dbg_offset
= dll
->dbg_offset
;
169 event
->data
.info
.load_dll
.dbg_size
= dll
->dbg_size
;
170 event
->data
.info
.load_dll
.name
= dll
->name
;
171 event
->data
.info
.load_dll
.unicode
= 0;
175 static int fill_unload_dll_event( struct debug_event
*event
, void *arg
)
177 event
->data
.info
.unload_dll
.base
= arg
;
181 static int fill_output_debug_string_event( struct debug_event
*event
, void *arg
)
183 struct output_debug_string_request
*req
= arg
;
184 event
->data
.info
.output_string
.string
= req
->string
;
185 event
->data
.info
.output_string
.unicode
= req
->unicode
;
186 event
->data
.info
.output_string
.length
= req
->length
;
190 typedef int (*fill_event_func
)( struct debug_event
*event
, void *arg
);
192 #define NB_DEBUG_EVENTS OUTPUT_DEBUG_STRING_EVENT /* RIP_EVENT not supported */
194 static const fill_event_func fill_debug_event
[NB_DEBUG_EVENTS
] =
196 fill_exception_event
, /* EXCEPTION_DEBUG_EVENT */
197 fill_create_thread_event
, /* CREATE_THREAD_DEBUG_EVENT */
198 fill_create_process_event
, /* CREATE_PROCESS_DEBUG_EVENT */
199 fill_exit_thread_event
, /* EXIT_THREAD_DEBUG_EVENT */
200 fill_exit_process_event
, /* EXIT_PROCESS_DEBUG_EVENT */
201 fill_load_dll_event
, /* LOAD_DLL_DEBUG_EVENT */
202 fill_unload_dll_event
, /* UNLOAD_DLL_DEBUG_EVENT */
203 fill_output_debug_string_event
/* OUTPUT_DEBUG_STRING_EVENT */
207 /* unlink the first event from the queue */
208 static void unlink_event( struct debug_ctx
*debug_ctx
, struct debug_event
*event
)
210 if (event
->prev
) event
->prev
->next
= event
->next
;
211 else debug_ctx
->event_head
= event
->next
;
212 if (event
->next
) event
->next
->prev
= event
->prev
;
213 else debug_ctx
->event_tail
= event
->prev
;
214 event
->next
= event
->prev
= NULL
;
215 if (event
->sender
->debug_event
== event
) event
->sender
->debug_event
= NULL
;
216 release_object( event
);
219 /* link an event at the end of the queue */
220 static void link_event( struct debug_ctx
*debug_ctx
, struct debug_event
*event
)
222 grab_object( event
);
224 event
->prev
= debug_ctx
->event_tail
;
225 debug_ctx
->event_tail
= event
;
226 if (event
->prev
) event
->prev
->next
= event
;
227 else debug_ctx
->event_head
= event
;
228 if (!event
->sender
->debug_event
) wake_up( &debug_ctx
->obj
, 0 );
231 /* find the next event that we can send to the debugger */
232 static struct debug_event
*find_event_to_send( struct debug_ctx
*debug_ctx
)
234 struct debug_event
*event
;
235 for (event
= debug_ctx
->event_head
; event
; event
= event
->next
)
237 if (event
->state
== EVENT_SENT
) continue; /* already sent */
238 if (event
->sender
->debug_event
) continue; /* thread busy with another one */
244 /* build a reply for the wait_debug_event request */
245 static void build_wait_debug_reply( struct thread
*thread
, struct object
*obj
, int signaled
)
247 struct wait_debug_event_request
*req
= get_req_ptr( thread
);
251 struct debug_ctx
*debug_ctx
= (struct debug_ctx
*)obj
;
252 struct debug_event
*event
= find_event_to_send( debug_ctx
);
253 size_t size
= get_req_data_size(req
);
255 /* the object that woke us has to be our debug context */
256 assert( obj
->ops
== &debug_ctx_ops
);
259 event
->state
= EVENT_SENT
;
260 event
->sender
->debug_event
= event
;
261 req
->pid
= event
->sender
->process
;
262 req
->tid
= event
->sender
;
263 if (size
> sizeof(debug_event_t
)) size
= sizeof(debug_event_t
);
264 memcpy( get_req_data(req
), &event
->data
, size
);
265 set_req_data_size( req
, size
);
267 else /* timeout or error */
269 set_req_data_size( req
, 0 );
275 /* build a reply for the send_event request */
276 static void build_exception_event_reply( struct thread
*thread
, struct object
*obj
, int signaled
)
278 struct exception_event_request
*req
= get_req_ptr( thread
);
279 struct debug_event
*event
= (struct debug_event
*)obj
;
280 assert( obj
->ops
== &debug_event_ops
);
281 req
->status
= event
->status
;
282 thread
->context
= NULL
;
285 static void debug_event_dump( struct object
*obj
, int verbose
)
287 struct debug_event
*debug_event
= (struct debug_event
*)obj
;
288 assert( obj
->ops
== &debug_event_ops
);
289 fprintf( stderr
, "Debug event sender=%p code=%d state=%d\n",
290 debug_event
->sender
, debug_event
->data
.code
, debug_event
->state
);
293 static int debug_event_signaled( struct object
*obj
, struct thread
*thread
)
295 struct debug_event
*debug_event
= (struct debug_event
*)obj
;
296 assert( obj
->ops
== &debug_event_ops
);
297 return debug_event
->state
== EVENT_CONTINUED
;
300 static void debug_event_destroy( struct object
*obj
)
302 struct debug_event
*event
= (struct debug_event
*)obj
;
303 assert( obj
->ops
== &debug_event_ops
);
305 /* cannot still be in the queue */
306 assert( !event
->next
);
307 assert( !event
->prev
);
309 /* If the event has been sent already, the handles are now under the */
310 /* responsibility of the debugger process, so we don't touch them */
311 if (event
->state
== EVENT_QUEUED
)
313 struct process
*debugger
= event
->debugger
->process
;
314 switch(event
->data
.code
)
316 case CREATE_THREAD_DEBUG_EVENT
:
317 close_handle( debugger
, event
->data
.info
.create_thread
.handle
, NULL
);
319 case CREATE_PROCESS_DEBUG_EVENT
:
320 if (event
->data
.info
.create_process
.file
)
321 close_handle( debugger
, event
->data
.info
.create_process
.file
, NULL
);
322 close_handle( debugger
, event
->data
.info
.create_process
.thread
, NULL
);
323 close_handle( debugger
, event
->data
.info
.create_process
.process
, NULL
);
325 case LOAD_DLL_DEBUG_EVENT
:
326 if (event
->data
.info
.load_dll
.handle
)
327 close_handle( debugger
, event
->data
.info
.load_dll
.handle
, NULL
);
331 release_object( event
->sender
);
332 release_object( event
->debugger
);
335 static void debug_ctx_dump( struct object
*obj
, int verbose
)
337 struct debug_ctx
*debug_ctx
= (struct debug_ctx
*)obj
;
338 assert( obj
->ops
== &debug_ctx_ops
);
339 fprintf( stderr
, "Debug context head=%p tail=%p\n",
340 debug_ctx
->event_head
, debug_ctx
->event_tail
);
343 static int debug_ctx_signaled( struct object
*obj
, struct thread
*thread
)
345 struct debug_ctx
*debug_ctx
= (struct debug_ctx
*)obj
;
346 assert( obj
->ops
== &debug_ctx_ops
);
347 return find_event_to_send( debug_ctx
) != NULL
;
350 static void debug_ctx_destroy( struct object
*obj
)
352 struct debug_event
*event
;
353 struct debug_ctx
*debug_ctx
= (struct debug_ctx
*)obj
;
354 assert( obj
->ops
== &debug_ctx_ops
);
356 /* free all pending events */
357 while ((event
= debug_ctx
->event_head
) != NULL
) unlink_event( debug_ctx
, event
);
360 /* wait for a debug event (or send a reply at once if one is pending) */
361 static int wait_for_debug_event( int timeout
)
363 struct debug_ctx
*debug_ctx
= current
->debug_ctx
;
364 struct object
*obj
= &debug_ctx
->obj
;
368 if (!debug_ctx
) /* current thread is not a debugger */
370 set_error( STATUS_INVALID_HANDLE
);
375 flags
= SELECT_TIMEOUT
;
376 gettimeofday( &tv
, 0 );
377 add_timeout( &tv
, timeout
);
379 else tv
.tv_sec
= tv
.tv_usec
= 0;
380 return sleep_on( 1, &obj
, flags
, tv
.tv_sec
, tv
.tv_usec
, build_wait_debug_reply
);
383 /* continue a debug event */
384 static int continue_debug_event( struct process
*process
, struct thread
*thread
, int status
)
386 struct debug_event
*event
;
387 struct debug_ctx
*debug_ctx
= current
->debug_ctx
;
389 if (!debug_ctx
|| process
->debugger
!= current
|| thread
->process
!= process
) goto error
;
391 /* find the event in the queue */
392 for (event
= debug_ctx
->event_head
; event
; event
= event
->next
)
394 if (event
->state
!= EVENT_SENT
) continue;
395 if (event
->sender
== thread
) break;
397 if (!event
) goto error
;
399 assert( event
->sender
->debug_event
== event
);
401 event
->status
= status
;
402 event
->state
= EVENT_CONTINUED
;
403 wake_up( &event
->obj
, 0 );
405 unlink_event( debug_ctx
, event
);
406 resume_process( process
);
409 /* not debugging this process, or no such event */
410 set_error( STATUS_ACCESS_DENIED
); /* FIXME */
414 /* queue a debug event for a debugger */
415 static struct debug_event
*queue_debug_event( struct thread
*thread
, int code
, void *arg
)
417 struct thread
*debugger
= thread
->process
->debugger
;
418 struct debug_ctx
*debug_ctx
= debugger
->debug_ctx
;
419 struct debug_event
*event
;
421 assert( code
> 0 && code
<= NB_DEBUG_EVENTS
);
423 /* cannot queue a debug event for myself */
424 assert( debugger
->process
!= thread
->process
);
426 /* build the event */
427 if (!(event
= alloc_object( &debug_event_ops
, -1 ))) return NULL
;
430 event
->state
= EVENT_QUEUED
;
431 event
->sender
= (struct thread
*)grab_object( thread
);
432 event
->debugger
= (struct thread
*)grab_object( debugger
);
433 event
->data
.code
= code
;
435 if (!fill_debug_event
[code
-1]( event
, arg
))
437 event
->data
.code
= -1; /* make sure we don't attempt to close handles */
438 release_object( event
);
442 link_event( debug_ctx
, event
);
443 suspend_process( thread
->process
);
447 /* generate a debug event from inside the server and queue it */
448 void generate_debug_event( struct thread
*thread
, int code
, void *arg
)
450 if (thread
->process
->debugger
)
452 struct debug_event
*event
= queue_debug_event( thread
, code
, arg
);
453 if (event
) release_object( event
);
457 /* attach a process to a debugger thread and suspend it */
458 static int debugger_attach( struct process
*process
, struct thread
*debugger
)
460 struct thread
*thread
;
462 if (process
->debugger
) goto error
; /* already being debugged */
463 if (process
->init_event
) goto error
; /* still starting up */
465 /* make sure we don't create a debugging loop */
466 for (thread
= debugger
; thread
; thread
= thread
->process
->debugger
)
467 if (thread
->process
== process
) goto error
;
469 suspend_process( process
);
471 /* we must have been able to attach all threads */
472 for (thread
= process
->thread_list
; thread
; thread
= thread
->proc_next
)
473 if (!thread
->attached
)
475 fprintf( stderr
, "%p not attached\n", thread
);
476 resume_process( process
);
480 if (set_process_debugger( process
, debugger
)) return 1;
481 resume_process( process
);
485 set_error( STATUS_ACCESS_DENIED
);
489 /* generate all startup events of a given process */
490 void generate_startup_debug_events( struct process
*process
, void *entry
)
492 struct process_dll
*dll
;
493 struct thread
*thread
= process
->thread_list
;
495 /* generate creation events */
496 generate_debug_event( thread
, CREATE_PROCESS_DEBUG_EVENT
, entry
);
497 while ((thread
= thread
->proc_next
))
498 generate_debug_event( thread
, CREATE_THREAD_DEBUG_EVENT
, NULL
);
500 /* generate dll events (in loading order, i.e. reverse list order) */
501 for (dll
= &process
->exe
; dll
->next
; dll
= dll
->next
);
502 while (dll
!= &process
->exe
)
504 generate_debug_event( process
->thread_list
, LOAD_DLL_DEBUG_EVENT
, dll
);
509 /* set the debugger of a given process */
510 int set_process_debugger( struct process
*process
, struct thread
*debugger
)
512 struct debug_ctx
*debug_ctx
;
514 assert( !process
->debugger
);
516 if (!debugger
->debug_ctx
) /* need to allocate a context */
518 if (!(debug_ctx
= alloc_object( &debug_ctx_ops
, -1 ))) return 0;
519 debug_ctx
->event_head
= NULL
;
520 debug_ctx
->event_tail
= NULL
;
521 debugger
->debug_ctx
= debug_ctx
;
523 process
->debugger
= debugger
;
527 /* a thread is exiting */
528 void debug_exit_thread( struct thread
*thread
)
530 if (thread
->debug_ctx
) /* this thread is a debugger */
532 /* kill all debugged processes */
533 kill_debugged_processes( thread
, thread
->exit_code
);
534 release_object( thread
->debug_ctx
);
535 thread
->debug_ctx
= NULL
;
539 /* Wait for a debug event */
540 DECL_HANDLER(wait_debug_event
)
542 if (!wait_for_debug_event( req
->timeout
))
546 set_req_data_size( req
, 0 );
550 /* Continue a debug event */
551 DECL_HANDLER(continue_debug_event
)
553 struct process
*process
= get_process_from_id( req
->pid
);
556 struct thread
*thread
= get_thread_from_id( req
->tid
);
559 continue_debug_event( process
, thread
, req
->status
);
560 release_object( thread
);
562 release_object( process
);
566 /* Start debugging an existing process */
567 DECL_HANDLER(debug_process
)
569 struct debug_event_exception data
;
570 struct debug_event
*event
;
571 struct process
*process
= get_process_from_id( req
->pid
);
572 if (!process
) return;
574 if (debugger_attach( process
, current
))
576 generate_startup_debug_events( process
, NULL
);
577 resume_process( process
);
579 data
.record
.ExceptionCode
= EXCEPTION_BREAKPOINT
;
580 data
.record
.ExceptionFlags
= EXCEPTION_CONTINUABLE
;
581 data
.record
.ExceptionRecord
= NULL
;
582 data
.record
.ExceptionAddress
= get_thread_ip( process
->thread_list
);
583 data
.record
.NumberParameters
= 0;
585 if ((event
= queue_debug_event( process
->thread_list
, EXCEPTION_DEBUG_EVENT
, &data
)))
586 release_object( event
);
588 release_object( process
);
591 /* send an exception event */
592 DECL_HANDLER(exception_event
)
595 if (current
->process
->debugger
)
597 struct debug_event_exception data
;
598 struct debug_event
*event
;
599 CONTEXT
*context
= get_req_data( req
);
600 EXCEPTION_RECORD
*rec
= (EXCEPTION_RECORD
*)(context
+ 1);
602 if (get_req_data_size( req
) < sizeof(*rec
) + sizeof(*context
))
604 set_error( STATUS_INVALID_PARAMETER
);
608 data
.first
= req
->first
;
609 if ((event
= queue_debug_event( current
, EXCEPTION_DEBUG_EVENT
, &data
)))
611 struct object
*obj
= &event
->obj
;
612 current
->context
= context
;
613 sleep_on( 1, &obj
, 0, 0, 0, build_exception_event_reply
);
614 release_object( event
);
619 /* send an output string to the debugger */
620 DECL_HANDLER(output_debug_string
)
622 if (current
->process
->debugger
)
624 struct debug_event
*event
= queue_debug_event( current
, OUTPUT_DEBUG_STRING_EVENT
, req
);
625 if (event
) release_object( event
);