2 * Server-side debugger functions
4 * Copyright (C) 1999 Alexandre Julliard
20 struct debug_event
*next
; /* event queue */
21 struct debug_event
*prev
;
22 struct thread
*thread
; /* thread which sent this event */
23 int sent
; /* already sent to the debugger? */
24 int code
; /* event code */
25 union debug_event_data data
; /* event data */
30 struct thread
*owner
; /* thread owning this debug context */
31 int waiting
; /* is thread waiting for an event? */
32 struct timeout_user
*timeout
; /* timeout user for wait timeout */
33 struct debug_event
*event_head
; /* head of pending events queue */
34 struct debug_event
*event_tail
; /* tail of pending events queue */
37 /* size of the event data */
38 static const int event_sizes
[] =
41 sizeof(struct debug_event_exception
), /* EXCEPTION_DEBUG_EVENT */
42 sizeof(struct debug_event_create_thread
), /* CREATE_THREAD_DEBUG_EVENT */
43 sizeof(struct debug_event_create_process
), /* CREATE_PROCESS_DEBUG_EVENT */
44 sizeof(struct debug_event_exit
), /* EXIT_THREAD_DEBUG_EVENT */
45 sizeof(struct debug_event_exit
), /* EXIT_PROCESS_DEBUG_EVENT */
46 sizeof(struct debug_event_load_dll
), /* LOAD_DLL_DEBUG_EVENT */
47 sizeof(struct debug_event_unload_dll
), /* UNLOAD_DLL_DEBUG_EVENT */
48 sizeof(struct debug_event_output_string
), /* OUTPUT_DEBUG_STRING_EVENT */
49 sizeof(struct debug_event_rip_info
) /* RIP_EVENT */
53 /* initialise the fields that do not need to be filled by the client */
54 static int fill_debug_event( struct thread
*debugger
, struct thread
*thread
,
55 struct debug_event
*event
)
59 /* some events need special handling */
62 case CREATE_THREAD_DEBUG_EVENT
:
63 if ((event
->data
.create_thread
.handle
= alloc_handle( debugger
->process
, thread
,
64 /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
65 THREAD_ALL_ACCESS
, FALSE
)) == -1)
68 case CREATE_PROCESS_DEBUG_EVENT
:
69 if ((handle
= event
->data
.create_process
.file
) != -1)
71 if ((handle
= duplicate_handle( thread
->process
, handle
, debugger
->process
,
72 GENERIC_READ
, FALSE
, 0 )) == -1)
74 event
->data
.create_process
.file
= handle
;
76 if ((event
->data
.create_process
.process
= alloc_handle( debugger
->process
, thread
->process
,
77 /* documented: PROCESS_VM_READ | PROCESS_VM_WRITE */
78 PROCESS_ALL_ACCESS
, FALSE
)) == -1)
80 if (handle
!= -1) close_handle( debugger
->process
, handle
);
83 if ((event
->data
.create_process
.thread
= alloc_handle( debugger
->process
, thread
,
84 /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
85 THREAD_ALL_ACCESS
, FALSE
)) == -1)
87 if (handle
!= -1) close_handle( debugger
->process
, handle
);
88 close_handle( debugger
->process
, event
->data
.create_process
.process
);
92 case LOAD_DLL_DEBUG_EVENT
:
93 if ((handle
= event
->data
.load_dll
.handle
) != -1)
95 if ((handle
= duplicate_handle( thread
->process
, handle
, debugger
->process
,
96 GENERIC_READ
, FALSE
, 0 )) == -1)
98 event
->data
.load_dll
.handle
= handle
;
105 /* free a debug event structure */
106 static void free_event( struct thread
*debugger
, struct debug_event
*event
)
108 /* If the event has been sent already, the handles are now under the */
109 /* responsibility of the debugger process, so we don't touch them */
114 case CREATE_THREAD_DEBUG_EVENT
:
115 close_handle( debugger
->process
, event
->data
.create_thread
.handle
);
117 case CREATE_PROCESS_DEBUG_EVENT
:
118 if (event
->data
.create_process
.file
!= -1)
119 close_handle( debugger
->process
, event
->data
.create_process
.file
);
120 close_handle( debugger
->process
, event
->data
.create_process
.thread
);
121 close_handle( debugger
->process
, event
->data
.create_process
.process
);
123 case LOAD_DLL_DEBUG_EVENT
:
124 if (event
->data
.load_dll
.handle
!= -1)
125 close_handle( debugger
->process
, event
->data
.load_dll
.handle
);
129 event
->thread
->debug_event
= NULL
;
130 release_object( event
->thread
);
134 /* unlink the first event from the queue */
135 static void unlink_event( struct debug_ctx
*debug_ctx
, struct debug_event
*event
)
137 if (event
->prev
) event
->prev
->next
= event
->next
;
138 else debug_ctx
->event_head
= event
->next
;
139 if (event
->next
) event
->next
->prev
= event
->prev
;
140 else debug_ctx
->event_tail
= event
->prev
;
141 event
->next
= event
->prev
= NULL
;
144 /* link an event at the end of the queue */
145 static void link_event( struct debug_ctx
*debug_ctx
, struct debug_event
*event
)
148 event
->prev
= debug_ctx
->event_tail
;
149 if (event
->prev
) event
->prev
->next
= event
;
150 else debug_ctx
->event_head
= event
;
151 debug_ctx
->event_tail
= event
;
154 /* send the first queue event as a reply */
155 static void build_event_reply( struct debug_ctx
*debug_ctx
)
157 struct debug_event
*event
= debug_ctx
->event_head
;
158 struct thread
*thread
= event
->thread
;
159 struct wait_debug_event_request
*req
= get_req_ptr( debug_ctx
->owner
);
162 assert( debug_ctx
->waiting
);
164 unlink_event( debug_ctx
, event
);
166 req
->code
= event
->code
;
167 req
->pid
= thread
->process
;
169 debug_ctx
->waiting
= 0;
170 if (debug_ctx
->timeout
)
172 remove_timeout_user( debug_ctx
->timeout
);
173 debug_ctx
->timeout
= NULL
;
175 debug_ctx
->owner
->error
= 0;
176 memcpy( req
+ 1, &event
->data
, event_sizes
[event
->code
] );
179 /* timeout callback while waiting for a debug event */
180 static void wait_event_timeout( void *ctx
)
182 struct debug_ctx
*debug_ctx
= (struct debug_ctx
*)ctx
;
183 struct wait_debug_event_request
*req
= get_req_ptr( debug_ctx
->owner
);
185 assert( debug_ctx
->waiting
);
190 debug_ctx
->waiting
= 0;
191 debug_ctx
->timeout
= NULL
;
192 debug_ctx
->owner
->error
= WAIT_TIMEOUT
;
193 send_reply( debug_ctx
->owner
);
196 /* wait for a debug event (or send a reply at once if one is pending) */
197 static int wait_for_debug_event( int timeout
)
199 struct debug_ctx
*debug_ctx
= current
->debug_ctx
;
202 if (!debug_ctx
) /* current thread is not a debugger */
204 set_error( ERROR_INVALID_HANDLE
);
207 assert( !debug_ctx
->waiting
);
208 if (debug_ctx
->event_head
) /* already have a pending event */
210 debug_ctx
->waiting
= 1;
211 build_event_reply( debug_ctx
);
214 if (!timeout
) /* no event and we don't want to wait */
216 set_error( WAIT_TIMEOUT
);
219 if (timeout
!= -1) /* start the timeout */
221 make_timeout( &when
, timeout
);
222 if (!(debug_ctx
->timeout
= add_timeout_user( &when
, wait_event_timeout
, debug_ctx
)))
225 debug_ctx
->waiting
= 1;
226 current
->state
= SLEEPING
;
230 /* continue a debug event */
231 static int continue_debug_event( struct process
*process
, struct thread
*thread
, int status
)
233 struct debug_event
*event
= thread
->debug_event
;
235 if (process
->debugger
!= current
|| thread
->process
!= process
|| !event
|| !event
->sent
)
237 /* not debugging this process, or no event pending */
238 set_error( ERROR_ACCESS_DENIED
); /* FIXME */
241 if (thread
->state
!= TERMINATED
)
243 /* only send a reply if the thread is still there */
244 /* (we can get a continue on an exit thread/process event) */
245 struct send_debug_event_request
*req
= get_req_ptr( thread
);
246 req
->status
= status
;
247 /* copy the context into the reply */
248 if (event
->code
== EXCEPTION_DEBUG_EVENT
)
249 memcpy( req
+ 1, &event
->data
, event_sizes
[event
->code
] );
250 send_reply( thread
);
253 free_event( current
, event
);
255 if (thread
->exit_event
)
257 /* we still have a queued exit event, promote it to normal event */
258 thread
->debug_event
= thread
->exit_event
;
259 thread
->exit_event
= NULL
;
261 resume_process( process
);
265 /* queue a debug event for a debugger */
266 static struct debug_event
*queue_debug_event( struct thread
*debugger
, struct thread
*thread
,
267 int code
, void *data
)
269 struct debug_ctx
*debug_ctx
= debugger
->debug_ctx
;
270 struct debug_event
*event
;
273 /* cannot queue a debug event for myself */
274 assert( debugger
->process
!= thread
->process
);
276 /* build the event */
277 if (!(event
= mem_alloc( sizeof(*event
) - sizeof(event
->data
) + event_sizes
[code
] )))
281 event
->thread
= (struct thread
*)grab_object( thread
);
282 memcpy( &event
->data
, data
, event_sizes
[code
] );
284 if (!fill_debug_event( debugger
, thread
, event
))
286 release_object( event
->thread
);
291 if (thread
->debug_event
)
293 /* exit events can happen while another one is still queued */
294 assert( code
== EXIT_THREAD_DEBUG_EVENT
|| code
== EXIT_PROCESS_DEBUG_EVENT
);
295 thread
->exit_event
= event
;
297 else thread
->debug_event
= event
;
299 link_event( debug_ctx
, event
);
300 suspend_process( thread
->process
);
301 if (debug_ctx
->waiting
)
303 build_event_reply( debug_ctx
);
304 send_reply( debug_ctx
->owner
);
309 /* attach a process to a debugger thread */
310 int debugger_attach( struct process
*process
, struct thread
*debugger
)
312 struct debug_ctx
*debug_ctx
;
313 struct thread
*thread
;
315 if (process
->debugger
) /* already being debugged */
317 set_error( ERROR_ACCESS_DENIED
);
320 /* make sure we don't create a debugging loop */
321 for (thread
= debugger
; thread
; thread
= thread
->process
->debugger
)
322 if (thread
->process
== process
)
324 set_error( ERROR_ACCESS_DENIED
);
328 if (!debugger
->debug_ctx
) /* need to allocate a context */
330 if (!(debug_ctx
= mem_alloc( sizeof(*debug_ctx
) ))) return 0;
331 debug_ctx
->owner
= current
;
332 debug_ctx
->waiting
= 0;
333 debug_ctx
->timeout
= NULL
;
334 debug_ctx
->event_head
= NULL
;
335 debug_ctx
->event_tail
= NULL
;
336 debugger
->debug_ctx
= debug_ctx
;
338 process
->debugger
= debugger
;
342 /* a thread is exiting */
343 void debug_exit_thread( struct thread
*thread
, int exit_code
)
345 struct thread
*debugger
= thread
->process
->debugger
;
346 struct debug_ctx
*debug_ctx
= thread
->debug_ctx
;
348 if (debugger
) /* being debugged -> send an event to the debugger */
350 struct debug_event_exit event
;
351 event
.exit_code
= exit_code
;
352 if (thread
->process
->running_threads
== 1)
353 /* this is the last thread, send an exit process event */
354 queue_debug_event( debugger
, thread
, EXIT_PROCESS_DEBUG_EVENT
, &event
);
356 queue_debug_event( debugger
, thread
, EXIT_THREAD_DEBUG_EVENT
, &event
);
359 if (debug_ctx
) /* this thread is a debugger */
361 struct debug_event
*event
;
363 /* kill all debugged processes */
364 kill_debugged_processes( thread
, exit_code
);
366 /* free all pending events */
367 while ((event
= debug_ctx
->event_head
) != NULL
)
369 unlink_event( debug_ctx
, event
);
370 free_event( thread
, event
);
372 /* remove the timeout */
373 if (debug_ctx
->timeout
) remove_timeout_user( debug_ctx
->timeout
);
374 thread
->debug_ctx
= NULL
;
379 /* Wait for a debug event */
380 DECL_HANDLER(wait_debug_event
)
382 if (!wait_for_debug_event( req
->timeout
))
390 /* Continue a debug event */
391 DECL_HANDLER(continue_debug_event
)
393 struct process
*process
= get_process_from_id( req
->pid
);
396 struct thread
*thread
= get_thread_from_id( req
->tid
);
399 continue_debug_event( process
, thread
, req
->status
);
400 release_object( thread
);
402 release_object( process
);
406 /* Start debugging an existing process */
407 DECL_HANDLER(debug_process
)
409 struct process
*process
= get_process_from_id( req
->pid
);
412 debugger_attach( process
, current
);
413 /* FIXME: should notice the debugged process somehow */
414 release_object( process
);
418 /* Send a debug event */
419 DECL_HANDLER(send_debug_event
)
421 struct thread
*debugger
= current
->process
->debugger
;
423 assert( !current
->debug_event
);
424 if ((req
->code
<= 0) || (req
->code
> RIP_EVENT
))
426 fatal_protocol_error( current
, "send_debug_event: bad code %d\n", req
->code
);
430 if (debugger
&& queue_debug_event( debugger
, current
, req
->code
, req
+ 1 ))
432 /* wait for continue_debug_event */
433 current
->state
= SLEEPING
;