usp10: Add Spacing Modifier Letters to the Latin script block.
[wine] / server / debugger.c
1 /*
2  * Server-side debugger functions
3  *
4  * Copyright (C) 1999 Alexandre Julliard
5  *
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.
10  *
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.
15  *
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
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <signal.h>
26 #include <string.h>
27 #include <stdarg.h>
28 #include <stdio.h>
29
30 #include "ntstatus.h"
31 #define WIN32_NO_STATUS
32 #include "windef.h"
33 #include "winternl.h"
34
35 #include "handle.h"
36 #include "file.h"
37 #include "process.h"
38 #include "thread.h"
39 #include "request.h"
40
41 enum debug_event_state { EVENT_QUEUED, EVENT_SENT, EVENT_CONTINUED };
42
43 /* debug event */
44 struct debug_event
45 {
46     struct object          obj;       /* object header */
47     struct list            entry;     /* entry in event queue */
48     struct thread         *sender;    /* thread which sent this event */
49     struct thread         *debugger;  /* debugger thread receiving the event */
50     enum debug_event_state state;     /* event state */
51     int                    status;    /* continuation status */
52     debug_event_t          data;      /* event data */
53     context_t              context;   /* register context */
54 };
55
56 /* debug context */
57 struct debug_ctx
58 {
59     struct object        obj;         /* object header */
60     struct list          event_queue; /* pending events queue */
61     int                  kill_on_exit;/* kill debuggees on debugger exit ? */
62 };
63
64
65 static void debug_event_dump( struct object *obj, int verbose );
66 static int debug_event_signaled( struct object *obj, struct thread *thread );
67 static void debug_event_destroy( struct object *obj );
68
69 static const struct object_ops debug_event_ops =
70 {
71     sizeof(struct debug_event),    /* size */
72     debug_event_dump,              /* dump */
73     no_get_type,                   /* get_type */
74     add_queue,                     /* add_queue */
75     remove_queue,                  /* remove_queue */
76     debug_event_signaled,          /* signaled */
77     no_satisfied,                  /* satisfied */
78     no_signal,                     /* signal */
79     no_get_fd,                     /* get_fd */
80     no_map_access,                 /* map_access */
81     default_get_sd,                /* get_sd */
82     default_set_sd,                /* set_sd */
83     no_lookup_name,                /* lookup_name */
84     no_open_file,                  /* open_file */
85     no_close_handle,               /* close_handle */
86     debug_event_destroy            /* destroy */
87 };
88
89 static void debug_ctx_dump( struct object *obj, int verbose );
90 static int debug_ctx_signaled( struct object *obj, struct thread *thread );
91 static void debug_ctx_destroy( struct object *obj );
92
93 static const struct object_ops debug_ctx_ops =
94 {
95     sizeof(struct debug_ctx),      /* size */
96     debug_ctx_dump,                /* dump */
97     no_get_type,                   /* get_type */
98     add_queue,                     /* add_queue */
99     remove_queue,                  /* remove_queue */
100     debug_ctx_signaled,            /* signaled */
101     no_satisfied,                  /* satisfied */
102     no_signal,                     /* signal */
103     no_get_fd,                     /* get_fd */
104     no_map_access,                 /* map_access */
105     default_get_sd,                /* get_sd */
106     default_set_sd,                /* set_sd */
107     no_lookup_name,                /* lookup_name */
108     no_open_file,                  /* open_file */
109     no_close_handle,               /* close_handle */
110     debug_ctx_destroy              /* destroy */
111 };
112
113
114 /* routines to build an event according to its type */
115
116 static int fill_exception_event( struct debug_event *event, const void *arg )
117 {
118     const debug_event_t *data = arg;
119     event->data.exception = data->exception;
120     event->data.exception.nb_params = min( event->data.exception.nb_params, EXCEPTION_MAXIMUM_PARAMETERS );
121     return 1;
122 }
123
124 static int fill_create_thread_event( struct debug_event *event, const void *arg )
125 {
126     struct process *debugger = event->debugger->process;
127     struct thread *thread = event->sender;
128     const client_ptr_t *entry = arg;
129     obj_handle_t handle;
130
131     /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
132     if (!(handle = alloc_handle( debugger, thread, THREAD_ALL_ACCESS, 0 ))) return 0;
133     event->data.create_thread.handle = handle;
134     event->data.create_thread.teb    = thread->teb;
135     if (entry) event->data.create_thread.start = *entry;
136     return 1;
137 }
138
139 static int fill_create_process_event( struct debug_event *event, const void *arg )
140 {
141     struct process *debugger = event->debugger->process;
142     struct thread *thread = event->sender;
143     struct process *process = thread->process;
144     struct process_dll *exe_module = get_process_exe_module( process );
145     const client_ptr_t *entry = arg;
146     obj_handle_t handle;
147
148     /* documented: PROCESS_VM_READ | PROCESS_VM_WRITE */
149     if (!(handle = alloc_handle( debugger, process, PROCESS_ALL_ACCESS, 0 ))) return 0;
150     event->data.create_process.process = handle;
151
152     /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
153     if (!(handle = alloc_handle( debugger, thread, THREAD_ALL_ACCESS, 0 )))
154     {
155         close_handle( debugger, event->data.create_process.process );
156         return 0;
157     }
158     event->data.create_process.thread     = handle;
159     event->data.create_process.file       = 0;
160     event->data.create_process.teb        = thread->teb;
161     event->data.create_process.base       = exe_module->base;
162     event->data.create_process.start      = *entry;
163     event->data.create_process.dbg_offset = exe_module->dbg_offset;
164     event->data.create_process.dbg_size   = exe_module->dbg_size;
165     event->data.create_process.name       = exe_module->name;
166     event->data.create_process.unicode    = 1;
167
168     if (exe_module->mapping)  /* the doc says write access too, but this doesn't seem a good idea */
169         event->data.create_process.file = open_mapping_file( debugger, exe_module->mapping, GENERIC_READ,
170                                                              FILE_SHARE_READ | FILE_SHARE_WRITE );
171     return 1;
172 }
173
174 static int fill_exit_thread_event( struct debug_event *event, const void *arg )
175 {
176     const struct thread *thread = arg;
177     event->data.exit.exit_code = thread->exit_code;
178     return 1;
179 }
180
181 static int fill_exit_process_event( struct debug_event *event, const void *arg )
182 {
183     const struct process *process = arg;
184     event->data.exit.exit_code = process->exit_code;
185     return 1;
186 }
187
188 static int fill_load_dll_event( struct debug_event *event, const void *arg )
189 {
190     struct process *debugger = event->debugger->process;
191     const struct process_dll *dll = arg;
192
193     event->data.load_dll.handle     = 0;
194     event->data.load_dll.base       = dll->base;
195     event->data.load_dll.dbg_offset = dll->dbg_offset;
196     event->data.load_dll.dbg_size   = dll->dbg_size;
197     event->data.load_dll.name       = dll->name;
198     event->data.load_dll.unicode    = 1;
199     if (dll->mapping)
200         event->data.load_dll.handle = open_mapping_file( debugger, dll->mapping, GENERIC_READ,
201                                                          FILE_SHARE_READ | FILE_SHARE_WRITE );
202     return 1;
203 }
204
205 static int fill_unload_dll_event( struct debug_event *event, const void *arg )
206 {
207     const mod_handle_t *base = arg;
208     event->data.unload_dll.base = *base;
209     return 1;
210 }
211
212 static int fill_output_debug_string_event( struct debug_event *event, const void *arg )
213 {
214     const debug_event_t *data = arg;
215     event->data.output_string = data->output_string;
216     return 1;
217 }
218
219 typedef int (*fill_event_func)( struct debug_event *event, const void *arg );
220
221 #define NB_DEBUG_EVENTS OUTPUT_DEBUG_STRING_EVENT  /* RIP_EVENT not supported */
222
223 static const fill_event_func fill_debug_event[NB_DEBUG_EVENTS] =
224 {
225     fill_exception_event,            /* EXCEPTION_DEBUG_EVENT */
226     fill_create_thread_event,        /* CREATE_THREAD_DEBUG_EVENT */
227     fill_create_process_event,       /* CREATE_PROCESS_DEBUG_EVENT */
228     fill_exit_thread_event,          /* EXIT_THREAD_DEBUG_EVENT */
229     fill_exit_process_event,         /* EXIT_PROCESS_DEBUG_EVENT */
230     fill_load_dll_event,             /* LOAD_DLL_DEBUG_EVENT */
231     fill_unload_dll_event,           /* UNLOAD_DLL_DEBUG_EVENT */
232     fill_output_debug_string_event   /* OUTPUT_DEBUG_STRING_EVENT */
233 };
234
235
236 /* unlink the first event from the queue */
237 static void unlink_event( struct debug_ctx *debug_ctx, struct debug_event *event )
238 {
239     list_remove( &event->entry );
240     if (event->sender->debug_event == event) event->sender->debug_event = NULL;
241     release_object( event );
242 }
243
244 /* link an event at the end of the queue */
245 static void link_event( struct debug_event *event )
246 {
247     struct debug_ctx *debug_ctx = event->debugger->debug_ctx;
248
249     assert( debug_ctx );
250     grab_object( event );
251     list_add_tail( &debug_ctx->event_queue, &event->entry );
252     if (!event->sender->debug_event) wake_up( &debug_ctx->obj, 0 );
253 }
254
255 /* find the next event that we can send to the debugger */
256 static struct debug_event *find_event_to_send( struct debug_ctx *debug_ctx )
257 {
258     struct debug_event *event;
259
260     LIST_FOR_EACH_ENTRY( event, &debug_ctx->event_queue, struct debug_event, entry )
261     {
262         if (event->state == EVENT_SENT) continue;  /* already sent */
263         if (event->sender->debug_event) continue;  /* thread busy with another one */
264         return event;
265     }
266     return NULL;
267 }
268
269 static void debug_event_dump( struct object *obj, int verbose )
270 {
271     struct debug_event *debug_event = (struct debug_event *)obj;
272     assert( obj->ops == &debug_event_ops );
273     fprintf( stderr, "Debug event sender=%p code=%d state=%d\n",
274              debug_event->sender, debug_event->data.code, debug_event->state );
275 }
276
277 static int debug_event_signaled( struct object *obj, struct thread *thread )
278 {
279     struct debug_event *debug_event = (struct debug_event *)obj;
280     assert( obj->ops == &debug_event_ops );
281     return debug_event->state == EVENT_CONTINUED;
282 }
283
284 static void debug_event_destroy( struct object *obj )
285 {
286     struct debug_event *event = (struct debug_event *)obj;
287     assert( obj->ops == &debug_event_ops );
288
289     /* If the event has been sent already, the handles are now under the */
290     /* responsibility of the debugger process, so we don't touch them    */
291     if (event->state == EVENT_QUEUED)
292     {
293         struct process *debugger = event->debugger->process;
294         switch(event->data.code)
295         {
296         case CREATE_THREAD_DEBUG_EVENT:
297             close_handle( debugger, event->data.create_thread.handle );
298             break;
299         case CREATE_PROCESS_DEBUG_EVENT:
300             if (event->data.create_process.file)
301                 close_handle( debugger, event->data.create_process.file );
302             close_handle( debugger, event->data.create_process.thread );
303             close_handle( debugger, event->data.create_process.process );
304             break;
305         case LOAD_DLL_DEBUG_EVENT:
306             if (event->data.load_dll.handle)
307                 close_handle( debugger, event->data.load_dll.handle );
308             break;
309         }
310     }
311     if (event->sender->context == &event->context)
312     {
313         event->sender->context = NULL;
314         stop_thread_if_suspended( event->sender );
315     }
316     release_object( event->sender );
317     release_object( event->debugger );
318 }
319
320 static void debug_ctx_dump( struct object *obj, int verbose )
321 {
322     struct debug_ctx *debug_ctx = (struct debug_ctx *)obj;
323     assert( obj->ops == &debug_ctx_ops );
324     fprintf( stderr, "Debug context head=%p tail=%p\n",
325              debug_ctx->event_queue.next, debug_ctx->event_queue.prev );
326 }
327
328 static int debug_ctx_signaled( struct object *obj, struct thread *thread )
329 {
330     struct debug_ctx *debug_ctx = (struct debug_ctx *)obj;
331     assert( obj->ops == &debug_ctx_ops );
332     return find_event_to_send( debug_ctx ) != NULL;
333 }
334
335 static void debug_ctx_destroy( struct object *obj )
336 {
337     struct list *ptr;
338     struct debug_ctx *debug_ctx = (struct debug_ctx *)obj;
339     assert( obj->ops == &debug_ctx_ops );
340
341     /* free all pending events */
342     while ((ptr = list_head( &debug_ctx->event_queue )))
343         unlink_event( debug_ctx, LIST_ENTRY( ptr, struct debug_event, entry ));
344 }
345
346 /* continue a debug event */
347 static int continue_debug_event( struct process *process, struct thread *thread, int status )
348 {
349     struct debug_ctx *debug_ctx = current->debug_ctx;
350
351     if (debug_ctx && process->debugger == current && thread->process == process)
352     {
353         struct debug_event *event;
354
355         /* find the event in the queue */
356         LIST_FOR_EACH_ENTRY( event, &debug_ctx->event_queue, struct debug_event, entry )
357         {
358             if (event->state != EVENT_SENT) continue;
359             if (event->sender == thread)
360             {
361                 assert( event->sender->debug_event == event );
362
363                 event->status = status;
364                 event->state  = EVENT_CONTINUED;
365                 wake_up( &event->obj, 0 );
366                 unlink_event( debug_ctx, event );
367                 resume_process( process );
368                 return 1;
369             }
370         }
371     }
372     /* not debugging this process, or no such event */
373     set_error( STATUS_ACCESS_DENIED );  /* FIXME */
374     return 0;
375 }
376
377 /* alloc a debug event for a debugger */
378 static struct debug_event *alloc_debug_event( struct thread *thread, int code, const void *arg )
379 {
380     struct thread *debugger = thread->process->debugger;
381     struct debug_event *event;
382
383     assert( code > 0 && code <= NB_DEBUG_EVENTS );
384     /* cannot queue a debug event for myself */
385     assert( debugger->process != thread->process );
386
387     /* build the event */
388     if (!(event = alloc_object( &debug_event_ops ))) return NULL;
389     event->state     = EVENT_QUEUED;
390     event->sender    = (struct thread *)grab_object( thread );
391     event->debugger  = (struct thread *)grab_object( debugger );
392     memset( &event->data, 0, sizeof(event->data) );
393
394     if (!fill_debug_event[code-1]( event, arg ))
395     {
396         event->data.code = -1;  /* make sure we don't attempt to close handles */
397         release_object( event );
398         return NULL;
399     }
400     event->data.code = code;
401     return event;
402 }
403
404 /* generate a debug event from inside the server and queue it */
405 void generate_debug_event( struct thread *thread, int code, const void *arg )
406 {
407     if (thread->process->debugger)
408     {
409         struct debug_event *event = alloc_debug_event( thread, code, arg );
410         if (event)
411         {
412             link_event( event );
413             suspend_process( thread->process );
414             release_object( event );
415         }
416         clear_error();  /* ignore errors */
417     }
418 }
419
420 /* attach a process to a debugger thread and suspend it */
421 static int debugger_attach( struct process *process, struct thread *debugger )
422 {
423     if (process->debugger) goto error;  /* already being debugged */
424     if (debugger->process == process) goto error;
425     if (!is_process_init_done( process )) goto error;  /* still starting up */
426     if (list_empty( &process->thread_list )) goto error;  /* no thread running in the process */
427
428     /* don't let a debugger debug its console... won't work */
429     if (debugger->process->console)
430     {
431         struct thread *renderer = console_get_renderer(debugger->process->console);
432         if (renderer && renderer->process == process)
433             goto error;
434     }
435
436     suspend_process( process );
437     if (!set_process_debugger( process, debugger ))
438     {
439         resume_process( process );
440         return 0;
441     }
442     if (!set_process_debug_flag( process, 1 ))
443     {
444         process->debugger = NULL;
445         resume_process( process );
446         return 0;
447     }
448     return 1;
449
450  error:
451     set_error( STATUS_ACCESS_DENIED );
452     return 0;
453 }
454
455
456 /* detach a process from a debugger thread (and resume it ?) */
457 int debugger_detach( struct process *process, struct thread *debugger )
458 {
459     struct debug_event *event, *next;
460     struct debug_ctx *debug_ctx;
461
462     if (!process->debugger || process->debugger != debugger)
463         goto error;  /* not currently debugged, or debugged by another debugger */
464     if (!debugger->debug_ctx ) goto error; /* should be a debugger */
465     /* init should be done, otherwise wouldn't be attached */
466     assert(is_process_init_done(process));
467
468     suspend_process( process );
469     /* send continue indication for all events */
470     debug_ctx = debugger->debug_ctx;
471
472     /* free all events from this process */
473     LIST_FOR_EACH_ENTRY_SAFE( event, next, &debug_ctx->event_queue, struct debug_event, entry )
474     {
475         if (event->sender->process != process) continue;
476
477         assert( event->state != EVENT_CONTINUED );
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 );
484     }
485
486     /* remove relationships between process and its debugger */
487     process->debugger = NULL;
488     process->debug_children = 0;
489     if (!set_process_debug_flag( process, 0 )) clear_error();  /* ignore error */
490
491     /* from this function */
492     resume_process( process );
493     return 0;
494
495  error:
496     set_error( STATUS_ACCESS_DENIED );
497     return 0;
498 }
499
500 /* generate all startup events of a given process */
501 void generate_startup_debug_events( struct process *process, client_ptr_t entry )
502 {
503     struct list *ptr;
504     struct thread *thread, *first_thread = get_process_first_thread( process );
505
506     /* generate creation events */
507     LIST_FOR_EACH_ENTRY( thread, &process->thread_list, struct thread, proc_entry )
508     {
509         if (thread == first_thread)
510             generate_debug_event( thread, CREATE_PROCESS_DEBUG_EVENT, &entry );
511         else
512             generate_debug_event( thread, CREATE_THREAD_DEBUG_EVENT, NULL );
513     }
514
515     /* generate dll events (in loading order, i.e. reverse list order) */
516     ptr = list_tail( &process->dlls );
517     while (ptr != list_head( &process->dlls ))
518     {
519         struct process_dll *dll = LIST_ENTRY( ptr, struct process_dll, entry );
520         generate_debug_event( first_thread, LOAD_DLL_DEBUG_EVENT, dll );
521         ptr = list_prev( &process->dlls, ptr );
522     }
523 }
524
525 /* set the debugger of a given process */
526 int set_process_debugger( struct process *process, struct thread *debugger )
527 {
528     struct debug_ctx *debug_ctx;
529
530     assert( !process->debugger );
531
532     if (!debugger->debug_ctx)  /* need to allocate a context */
533     {
534         if (!(debug_ctx = alloc_object( &debug_ctx_ops ))) return 0;
535         debug_ctx->kill_on_exit = 1;
536         list_init( &debug_ctx->event_queue );
537         debugger->debug_ctx = debug_ctx;
538     }
539     process->debugger = debugger;
540     return 1;
541 }
542
543 /* a thread is exiting */
544 void debug_exit_thread( struct thread *thread )
545 {
546     if (thread->debug_ctx)  /* this thread is a debugger */
547     {
548         if (thread->debug_ctx->kill_on_exit)
549         {
550             /* kill all debugged processes */
551             kill_debugged_processes( thread, STATUS_DEBUGGER_INACTIVE );
552         }
553         else
554         {
555             detach_debugged_processes( thread );
556         }
557         release_object( thread->debug_ctx );
558         thread->debug_ctx = NULL;
559     }
560 }
561
562 /* Wait for a debug event */
563 DECL_HANDLER(wait_debug_event)
564 {
565     struct debug_ctx *debug_ctx = current->debug_ctx;
566     struct debug_event *event;
567
568     if (!debug_ctx)  /* current thread is not a debugger */
569     {
570         set_error( STATUS_INVALID_HANDLE );
571         return;
572     }
573     reply->wait = 0;
574     if ((event = find_event_to_send( debug_ctx )))
575     {
576         data_size_t size = get_reply_max_size();
577         event->state = EVENT_SENT;
578         event->sender->debug_event = event;
579         reply->pid = get_process_id( event->sender->process );
580         reply->tid = get_thread_id( event->sender );
581         if (size > sizeof(debug_event_t)) size = sizeof(debug_event_t);
582         set_reply_data( &event->data, size );
583     }
584     else  /* no event ready */
585     {
586         reply->pid  = 0;
587         reply->tid  = 0;
588         if (req->get_handle)
589             reply->wait = alloc_handle( current->process, debug_ctx, SYNCHRONIZE, 0 );
590     }
591 }
592
593 /* Continue a debug event */
594 DECL_HANDLER(continue_debug_event)
595 {
596     struct process *process = get_process_from_id( req->pid );
597     if (process)
598     {
599         struct thread *thread = get_thread_from_id( req->tid );
600         if (thread)
601         {
602             continue_debug_event( process, thread, req->status );
603             release_object( thread );
604         }
605         release_object( process );
606     }
607 }
608
609 /* Start debugging an existing process */
610 DECL_HANDLER(debug_process)
611 {
612     struct process *process = get_process_from_id( req->pid );
613     if (!process) return;
614
615     if (!req->attach)
616     {
617         debugger_detach( process, current );
618     }
619     else if (debugger_attach( process, current ))
620     {
621         generate_startup_debug_events( process, 0 );
622         break_process( process );
623         resume_process( process );
624     }
625     release_object( process );
626 }
627
628 /* queue an exception event */
629 DECL_HANDLER(queue_exception_event)
630 {
631     reply->handle = 0;
632     if (current->process->debugger)
633     {
634         debug_event_t data;
635         struct debug_event *event;
636         struct thread *thread = current;
637
638         if ((req->len % sizeof(client_ptr_t)) != 0 ||
639             req->len > get_req_data_size() ||
640             req->len > EXCEPTION_MAXIMUM_PARAMETERS * sizeof(client_ptr_t))
641         {
642             set_error( STATUS_INVALID_PARAMETER );
643             return;
644         }
645         memset( &data, 0, sizeof(data) );
646         data.exception.first     = req->first;
647         data.exception.exc_code  = req->code;
648         data.exception.flags     = req->flags;
649         data.exception.record    = req->record;
650         data.exception.address   = req->address;
651         data.exception.nb_params = req->len / sizeof(client_ptr_t);
652         memcpy( data.exception.params, get_req_data(), req->len );
653
654         if ((event = alloc_debug_event( thread, EXCEPTION_DEBUG_EVENT, &data )))
655         {
656             const context_t *context = (const context_t *)((const char *)get_req_data() + req->len);
657             data_size_t size = get_req_data_size() - req->len;
658
659             memset( &event->context, 0, sizeof(event->context) );
660             memcpy( &event->context, context, min( sizeof(event->context), size ) );
661             thread->context = &event->context;
662
663             if ((reply->handle = alloc_handle( thread->process, event, SYNCHRONIZE, 0 )))
664             {
665                 link_event( event );
666                 suspend_process( thread->process );
667             }
668             release_object( event );
669         }
670     }
671 }
672
673 /* retrieve the status of an exception event */
674 DECL_HANDLER(get_exception_status)
675 {
676     struct debug_event *event;
677
678     if ((event = (struct debug_event *)get_handle_obj( current->process, req->handle,
679                                                        0, &debug_event_ops )))
680     {
681         close_handle( current->process, req->handle );
682         if (event->state == EVENT_CONTINUED)
683         {
684             if (current->context == &event->context)
685             {
686                 data_size_t size = min( sizeof(context_t), get_reply_max_size() );
687                 set_reply_data( &event->context, size );
688                 current->context = NULL;
689                 stop_thread_if_suspended( current );
690             }
691             set_error( event->status );
692         }
693         else set_error( STATUS_PENDING );
694         release_object( event );
695     }
696 }
697
698 /* send an output string to the debugger */
699 DECL_HANDLER(output_debug_string)
700 {
701     debug_event_t data;
702
703     data.output_string.string  = req->string;
704     data.output_string.length  = req->length;
705     generate_debug_event( current, OUTPUT_DEBUG_STRING_EVENT, &data );
706 }
707
708 /* simulate a breakpoint in a process */
709 DECL_HANDLER(debug_break)
710 {
711     struct process *process;
712
713     reply->self = 0;
714     if ((process = get_process_from_handle( req->handle, PROCESS_SET_INFORMATION /*FIXME*/ )))
715     {
716         if (process != current->process) break_process( process );
717         else reply->self = 1;
718         release_object( process );
719     }
720 }
721
722 /* set debugger kill on exit flag */
723 DECL_HANDLER(set_debugger_kill_on_exit)
724 {
725     if (!current->debug_ctx)
726     {
727         set_error( STATUS_ACCESS_DENIED );
728         return;
729     }
730     current->debug_ctx->kill_on_exit = req->kill_on_exit;
731 }