diff --git a/server/Makefile.in b/server/Makefile.in
index b4ec97a..e2bad9f 100644
--- a/server/Makefile.in
+++ b/server/Makefile.in
@@ -8,6 +8,7 @@
 C_SRCS = \
 	change.c \
 	console.c \
+	context_i386.c \
 	debugger.c \
 	device.c \
 	event.c \
diff --git a/server/context_i386.c b/server/context_i386.c
new file mode 100644
index 0000000..129577c
--- /dev/null
+++ b/server/context_i386.c
@@ -0,0 +1,264 @@
+/*
+ * i386 register context support
+ *
+ * Copyright (C) 1999 Alexandre Julliard
+ */
+
+#include "config.h"
+
+#ifdef __i386__
+
+#include <assert.h>
+#include <errno.h>
+#include <sys/ptrace.h>
+#include <sys/user.h>
+
+#include "winbase.h"
+#include "winerror.h"
+
+#include "thread.h"
+#include "request.h"
+
+
+#ifndef PTRACE_PEEKUSER
+#define PTRACE_PEEKUSER PT_READ_U
+#endif
+#ifndef PTRACE_POKEUSER
+#define PTRACE_POKEUSER PT_WRITE_U
+#endif
+#ifndef PTRACE_GETREGS
+#define PTRACE_GETREGS PT_GETREGS
+#endif
+#ifndef PTRACE_GETFPREGS
+#define PTRACE_GETFPREGS PT_GETFPREGS
+#endif
+
+#ifdef linux
+
+/* debug register offset in struct user */
+#define DR_OFFSET(dr) ((int)((((struct user *)0)->u_debugreg) + (dr)))
+
+/* retrieve a debug register */
+static inline int get_debug_reg( int pid, int num, DWORD *data )
+{
+    int res = ptrace( PTRACE_PEEKUSER, pid, DR_OFFSET(num), 0 );
+    if ((res == -1) && errno)
+    {
+        file_set_error();
+        return -1;
+    }
+    *data = res;
+    return 0;
+}
+
+/* retrieve a thread context */
+static void get_thread_context( struct thread *thread, unsigned int flags, CONTEXT *context )
+{
+    int pid = thread->unix_pid;
+    if (flags & CONTEXT_FULL)
+    {
+        struct user_regs_struct regs;
+        if (ptrace( PTRACE_GETREGS, pid, 0, &regs ) == -1) goto error;
+        if (flags & CONTEXT_INTEGER)
+        {
+            context->Eax = regs.eax;
+            context->Ebx = regs.ebx;
+            context->Ecx = regs.ecx;
+            context->Edx = regs.edx;
+            context->Esi = regs.esi;
+            context->Edi = regs.edi;
+        }
+        if (flags & CONTEXT_CONTROL)
+        {
+            context->Ebp    = regs.ebp;
+            context->Esp    = regs.esp;
+            context->Eip    = regs.eip;
+            context->SegCs  = regs.xcs & 0xffff;
+            context->SegSs  = regs.xss & 0xffff;
+            context->EFlags = regs.eflags;
+        }
+        if (flags & CONTEXT_SEGMENTS)
+        {
+            context->SegDs = regs.xds & 0xffff;
+            context->SegEs = regs.xes & 0xffff;
+            context->SegFs = regs.xfs & 0xffff;
+            context->SegGs = regs.xgs & 0xffff;
+        }
+    }
+    if (flags & CONTEXT_DEBUG_REGISTERS)
+    {
+        if (get_debug_reg( pid, 0, &context->Dr0 ) == -1) goto error;
+        if (get_debug_reg( pid, 1, &context->Dr1 ) == -1) goto error;
+        if (get_debug_reg( pid, 2, &context->Dr2 ) == -1) goto error;
+        if (get_debug_reg( pid, 3, &context->Dr3 ) == -1) goto error;
+        if (get_debug_reg( pid, 6, &context->Dr6 ) == -1) goto error;
+        if (get_debug_reg( pid, 7, &context->Dr7 ) == -1) goto error;
+    }
+    if (flags & CONTEXT_FLOATING_POINT)
+    {
+        /* we can use context->FloatSave directly as it is using the */
+        /* correct structure (the same as fsave/frstor) */
+        if (ptrace( PTRACE_GETFPREGS, pid, 0, &context->FloatSave ) == -1) goto error;
+        context->FloatSave.Cr0NpxState = 0;  /* FIXME */
+    }
+    return;
+ error:
+    file_set_error();
+}
+
+
+/* set a thread context */
+static void set_thread_context( struct thread *thread, unsigned int flags, CONTEXT *context )
+{
+    int pid = thread->unix_pid;
+    if (flags & CONTEXT_FULL)
+    {
+        struct user_regs_struct regs;
+        if ((flags & CONTEXT_FULL) != CONTEXT_FULL)  /* need to preserve some registers */
+        {
+            if (ptrace( PTRACE_GETREGS, pid, 0, &regs ) == -1) goto error;
+        }
+        if (flags & CONTEXT_INTEGER)
+        {
+            regs.eax = context->Eax;
+            regs.ebx = context->Ebx;
+            regs.ecx = context->Ecx;
+            regs.edx = context->Edx;
+            regs.esi = context->Esi;
+            regs.edi = context->Edi;
+        }
+        if (flags & CONTEXT_CONTROL)
+        {
+            regs.ebp = context->Ebp;
+            regs.esp = context->Esp;
+            regs.eip = context->Eip;
+            regs.xcs = context->SegCs;
+            regs.xss = context->SegSs;
+            regs.eflags = context->EFlags;
+        }
+        if (flags & CONTEXT_SEGMENTS)
+        {
+            regs.xds = context->SegDs;
+            regs.xes = context->SegEs;
+            regs.xfs = context->SegFs;
+            regs.xgs = context->SegGs;
+        }
+        if (ptrace( PTRACE_SETREGS, pid, 0, &regs ) == -1) goto error;
+    }
+    if (flags & CONTEXT_DEBUG_REGISTERS)
+    {
+        if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(0), context->Dr0 ) == -1) goto error;
+        if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(1), context->Dr1 ) == -1) goto error;
+        if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(2), context->Dr2 ) == -1) goto error;
+        if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(3), context->Dr3 ) == -1) goto error;
+        if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(6), context->Dr6 ) == -1) goto error;
+        if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(7), context->Dr7 ) == -1) goto error;
+    }
+    if (flags & CONTEXT_FLOATING_POINT)
+    {
+        /* we can use context->FloatSave directly as it is using the */
+        /* correct structure (the same as fsave/frstor) */
+        if (ptrace( PTRACE_SETFPREGS, pid, 0, &context->FloatSave ) == -1) goto error;
+        context->FloatSave.Cr0NpxState = 0;  /* FIXME */
+    }
+    return;
+ error:
+    file_set_error();
+}
+
+#else  /* linux */
+#error You must implement get/set_thread_context for your platform
+#endif  /* linux */
+
+
+/* copy a context structure according to the flags */
+static void copy_context( CONTEXT *to, CONTEXT *from, int flags )
+{
+    if (flags & CONTEXT_CONTROL)
+    {
+        to->Ebp    = from->Ebp;
+        to->Eip    = from->Eip;
+        to->Esp    = from->Esp;
+        to->SegCs  = from->SegCs;
+        to->SegSs  = from->SegSs;
+        to->EFlags = from->EFlags;
+    }
+    if (flags & CONTEXT_INTEGER)
+    {
+        to->Eax = from->Eax;
+        to->Ebx = from->Ebx;
+        to->Ecx = from->Ecx;
+        to->Edx = from->Edx;
+        to->Esi = from->Esi;
+        to->Edi = from->Edi;
+    }
+    if (flags & CONTEXT_SEGMENTS)
+    {
+        to->SegDs = from->SegDs;
+        to->SegEs = from->SegEs;
+        to->SegFs = from->SegFs;
+        to->SegGs = from->SegGs;
+    }
+    if (flags & CONTEXT_DEBUG_REGISTERS)
+    {
+        to->Dr0 = from->Dr0;
+        to->Dr1 = from->Dr1;
+        to->Dr2 = from->Dr2;
+        to->Dr3 = from->Dr3;
+        to->Dr6 = from->Dr6;
+        to->Dr7 = from->Dr7;
+    }
+    if (flags & CONTEXT_FLOATING_POINT)
+    {
+        to->FloatSave = from->FloatSave;
+    }
+}
+
+/* retrieve the current context of a thread */
+DECL_HANDLER(get_thread_context)
+{
+    struct thread *thread;
+    CONTEXT *context;
+
+    if ((thread = get_thread_from_handle( req->handle, THREAD_GET_CONTEXT )))
+    {
+        if ((context = get_debug_context( thread )))  /* thread is inside an exception event */
+        {
+            copy_context( &req->context, context, req->flags );
+        }
+        else
+        {
+            suspend_thread( thread, 0 );
+            if (thread->attached) get_thread_context( thread, req->flags, &req->context );
+            else set_error( ERROR_ACCESS_DENIED );
+            resume_thread( thread );
+        }
+        release_object( thread );
+    }
+}
+
+
+/* set the current context of a thread */
+DECL_HANDLER(set_thread_context)
+{
+    struct thread *thread;
+    CONTEXT *context;
+
+    if ((thread = get_thread_from_handle( req->handle, THREAD_SET_CONTEXT )))
+    {
+        if ((context = get_debug_context( thread )))  /* thread is inside an exception event */
+        {
+            copy_context( context, &req->context, req->flags );
+        }
+        else
+        {
+            suspend_thread( thread, 0 );
+            if (thread->attached) set_thread_context( thread, req->flags, &req->context );
+            else set_error( ERROR_ACCESS_DENIED );
+            resume_thread( thread );
+        }
+        release_object( thread );
+    }
+}
+
+#endif  /* __i386__ */
diff --git a/server/debugger.c b/server/debugger.c
index 6e370e0..7cbf183 100644
--- a/server/debugger.c
+++ b/server/debugger.c
@@ -28,8 +28,7 @@
     struct thread         *debugger;  /* debugger thread receiving the event */
     enum debug_event_state state;     /* event state */
     int                    status;    /* continuation status */
-    int                    code;      /* event code */
-    union debug_event_data data;      /* event data */
+    debug_event_t          data;      /* event data */
 };
 
 /* debug context */
@@ -84,21 +83,6 @@
     debug_ctx_destroy              /* destroy */
 };
 
-/* size of the event data */
-static const int event_sizes[] =
-{
-    0,
-    sizeof(struct debug_event_exception),       /* EXCEPTION_DEBUG_EVENT */
-    sizeof(struct debug_event_create_thread),   /* CREATE_THREAD_DEBUG_EVENT */
-    sizeof(struct debug_event_create_process),  /* CREATE_PROCESS_DEBUG_EVENT */
-    sizeof(struct debug_event_exit),            /* EXIT_THREAD_DEBUG_EVENT */
-    sizeof(struct debug_event_exit),            /* EXIT_PROCESS_DEBUG_EVENT */
-    sizeof(struct debug_event_load_dll),        /* LOAD_DLL_DEBUG_EVENT */
-    sizeof(struct debug_event_unload_dll),      /* UNLOAD_DLL_DEBUG_EVENT */
-    sizeof(struct debug_event_output_string),   /* OUTPUT_DEBUG_STRING_EVENT */
-    sizeof(struct debug_event_rip_info)         /* RIP_EVENT */
-};
-
 
 /* initialise the fields that do not need to be filled by the client */
 static int fill_debug_event( struct thread *debugger, struct thread *thread,
@@ -107,45 +91,45 @@
     int handle;
 
     /* some events need special handling */
-    switch(event->code)
+    switch(event->data.code)
     {
     case CREATE_THREAD_DEBUG_EVENT:
-        if ((event->data.create_thread.handle = alloc_handle( debugger->process, thread,
+        if ((event->data.info.create_thread.handle = alloc_handle( debugger->process, thread,
                /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
                                                               THREAD_ALL_ACCESS, FALSE )) == -1)
             return 0;
         break;
     case CREATE_PROCESS_DEBUG_EVENT:
-        if ((handle = event->data.create_process.file) != -1)
+        if ((handle = event->data.info.create_process.file) != -1)
         {
             if ((handle = duplicate_handle( thread->process, handle, debugger->process,
                                             GENERIC_READ, FALSE, 0 )) == -1)
                 return 0;
-            event->data.create_process.file = handle;
+            event->data.info.create_process.file = handle;
         }
-        if ((event->data.create_process.process = alloc_handle( debugger->process, thread->process,
+        if ((event->data.info.create_process.process = alloc_handle( debugger->process, thread->process,
                                            /* documented: PROCESS_VM_READ | PROCESS_VM_WRITE */
                                                                 PROCESS_ALL_ACCESS, FALSE )) == -1)
         {
             if (handle != -1) close_handle( debugger->process, handle );
             return 0;
         }
-        if ((event->data.create_process.thread = alloc_handle( debugger->process, thread,
+        if ((event->data.info.create_process.thread = alloc_handle( debugger->process, thread,
                /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
                                                                THREAD_ALL_ACCESS, FALSE )) == -1)
         {
             if (handle != -1) close_handle( debugger->process, handle );
-            close_handle( debugger->process, event->data.create_process.process );
+            close_handle( debugger->process, event->data.info.create_process.process );
             return 0;
         }
         break;
     case LOAD_DLL_DEBUG_EVENT:
-        if ((handle = event->data.load_dll.handle) != -1)
+        if ((handle = event->data.info.load_dll.handle) != -1)
         {
             if ((handle = duplicate_handle( thread->process, handle, debugger->process,
                                             GENERIC_READ, FALSE, 0 )) == -1)
                 return 0;
-            event->data.load_dll.handle = handle;
+            event->data.info.load_dll.handle = handle;
         }
         break;
     }
@@ -196,14 +180,14 @@
 
         event->state = EVENT_SENT;
         debug_ctx->to_send = event->next;
-        req->code = event->code;
+        req->event.code = event->data.code;
         req->pid  = event->sender->process;
         req->tid  = event->sender;
-        memcpy( req + 1, &event->data, event_sizes[event->code] );
+        memcpy( &req->event, &event->data, sizeof(req->event) );
     }
     else  /* timeout or error */
     {
-        req->code = 0;
+        req->event.code = 0;
         req->pid  = 0;
         req->tid  = 0;
         thread->error = signaled;
@@ -219,8 +203,10 @@
 
     req->status = event->status;
     /* copy the context into the reply */
-    if (event->code == EXCEPTION_DEBUG_EVENT)
-        memcpy( req + 1, &event->data, event_sizes[event->code] );
+    if (event->data.code == EXCEPTION_DEBUG_EVENT)
+        memcpy( &req->event.info.exception.context,
+                &event->data.info.exception.context,
+                sizeof(req->event.info.exception.context) );
 }
 
 static void debug_event_dump( struct object *obj, int verbose )
@@ -228,7 +214,7 @@
     struct debug_event *debug_event = (struct debug_event *)obj;
     assert( obj->ops == &debug_event_ops );
     fprintf( stderr, "Debug event sender=%p code=%d state=%d\n",
-             debug_event->sender, debug_event->code, debug_event->state );
+             debug_event->sender, debug_event->data.code, debug_event->state );
 }
 
 static int debug_event_signaled( struct object *obj, struct thread *thread )
@@ -252,20 +238,20 @@
     if (event->state == EVENT_QUEUED)
     {
         struct process *debugger = event->debugger->process;
-        switch(event->code)
+        switch(event->data.code)
         {
         case CREATE_THREAD_DEBUG_EVENT:
-            close_handle( debugger, event->data.create_thread.handle );
+            close_handle( debugger, event->data.info.create_thread.handle );
             break;
         case CREATE_PROCESS_DEBUG_EVENT:
-            if (event->data.create_process.file != -1)
-                close_handle( debugger, event->data.create_process.file );
-            close_handle( debugger, event->data.create_process.thread );
-            close_handle( debugger, event->data.create_process.process );
+            if (event->data.info.create_process.file != -1)
+                close_handle( debugger, event->data.info.create_process.file );
+            close_handle( debugger, event->data.info.create_process.thread );
+            close_handle( debugger, event->data.info.create_process.process );
             break;
         case LOAD_DLL_DEBUG_EVENT:
-            if (event->data.load_dll.handle != -1)
-                close_handle( debugger, event->data.load_dll.handle );
+            if (event->data.info.load_dll.handle != -1)
+                close_handle( debugger, event->data.info.load_dll.handle );
             break;
         }
     }
@@ -346,7 +332,7 @@
 
 /* queue a debug event for a debugger */
 static struct debug_event *queue_debug_event( struct thread *debugger, struct thread *thread,
-                                              int code, void *data )
+                                              debug_event_t *data )
 {
     struct debug_ctx *debug_ctx = debugger->debug_ctx;
     struct debug_event *event;
@@ -360,14 +346,13 @@
     event->next     = NULL;
     event->prev     = NULL;
     event->state    = EVENT_QUEUED;
-    event->code     = code;
     event->sender   = (struct thread *)grab_object( thread );
     event->debugger = (struct thread *)grab_object( debugger );
-    memcpy( &event->data, data, event_sizes[code] );
+    memcpy( &event->data, data, sizeof(event->data) );
 
     if (!fill_debug_event( debugger, thread, event ))
     {
-        event->code = -1;  /* make sure we don't attempt to close handles */
+        event->data.code = -1;  /* make sure we don't attempt to close handles */
         release_object( event );
         return NULL;
     }
@@ -377,6 +362,22 @@
     return event;
 }
 
+/* return a pointer to the context in case the thread is inside an exception event */
+CONTEXT *get_debug_context( struct thread *thread )
+{
+    struct debug_event *event;
+    struct thread *debugger = thread->process->debugger;
+
+    if (!debugger) return NULL;  /* not being debugged */
+    assert( debugger->debug_ctx );
+
+    /* find the exception event in the debugger's queue */
+    for (event = debugger->debug_ctx->event_head; event; event = event->next)
+        if (event->sender == thread && (event->data.code == EXCEPTION_DEBUG_EVENT))
+            return &event->data.info.exception.context;
+    return NULL;
+}
+
 /* attach a process to a debugger thread */
 int debugger_attach( struct process *process, struct thread *debugger )
 {
@@ -417,13 +418,12 @@
     if (debugger)  /* being debugged -> send an event to the debugger */
     {
         struct debug_event *event;
-        struct debug_event_exit exit;
-        exit.exit_code = exit_code;
-        if (thread->process->running_threads == 1)
-            /* this is the last thread, send an exit process event */
-            event = queue_debug_event( debugger, thread, EXIT_PROCESS_DEBUG_EVENT, &exit );
-        else
-            event = queue_debug_event( debugger, thread, EXIT_THREAD_DEBUG_EVENT, &exit );
+        debug_event_t exit;
+        exit.info.exit.exit_code = exit_code;
+        /* if this is the last thread, send an exit process event */
+        exit.code = ((thread->process->running_threads == 1) ?
+                     EXIT_PROCESS_DEBUG_EVENT : EXIT_THREAD_DEBUG_EVENT);
+        event = queue_debug_event( debugger, thread, &exit );
         if (event) release_object( event );
     }
 
@@ -441,9 +441,9 @@
 {
     if (!wait_for_debug_event( req->timeout ))
     {
-        req->code = 0;
-        req->pid  = NULL;
-        req->tid  = NULL;
+        req->event.code = 0;
+        req->pid = NULL;
+        req->tid = NULL;
     }
 }
 
@@ -481,13 +481,13 @@
     struct thread *debugger = current->process->debugger;
     struct debug_event *event;
 
-    if ((req->code <= 0) || (req->code > RIP_EVENT))
+    if ((req->event.code <= 0) || (req->event.code > RIP_EVENT))
     {
-        fatal_protocol_error( current, "send_debug_event: bad code %d\n", req->code );
+        fatal_protocol_error( current, "send_debug_event: bad code %d\n", req->event.code );
         return;
     }
     req->status = 0;
-    if (debugger && ((event = queue_debug_event( debugger, current, req->code, req + 1 ))))
+    if (debugger && ((event = queue_debug_event( debugger, current, &req->event ))))
     {
         /* wait for continue_debug_event */
         struct object *obj = &event->obj;
diff --git a/server/object.h b/server/object.h
index 5825dce..fb874f7 100644
--- a/server/object.h
+++ b/server/object.h
@@ -155,6 +155,7 @@
 
 extern int debugger_attach( struct process *process, struct thread *debugger );
 extern void debug_exit_thread( struct thread *thread, int exit_code );
+extern CONTEXT *get_debug_context( struct thread *thread );
 
 /* mapping functions */
 
diff --git a/server/request.h b/server/request.h
index da50d44..80ad9aa 100644
--- a/server/request.h
+++ b/server/request.h
@@ -157,6 +157,8 @@
 DECL_HANDLER(open_timer);
 DECL_HANDLER(set_timer);
 DECL_HANDLER(cancel_timer);
+DECL_HANDLER(get_thread_context);
+DECL_HANDLER(set_thread_context);
 
 #ifdef WANT_REQUEST_HANDLERS
 
@@ -254,6 +256,8 @@
     { (void(*)())req_open_timer, sizeof(struct open_timer_request) },
     { (void(*)())req_set_timer, sizeof(struct set_timer_request) },
     { (void(*)())req_cancel_timer, sizeof(struct cancel_timer_request) },
+    { (void(*)())req_get_thread_context, sizeof(struct get_thread_context_request) },
+    { (void(*)())req_set_thread_context, sizeof(struct set_thread_context_request) },
 };
 #endif  /* WANT_REQUEST_HANDLERS */
 
diff --git a/server/trace.c b/server/trace.c
index 35fb9e7..7fc5eb6 100644
--- a/server/trace.c
+++ b/server/trace.c
@@ -9,6 +9,7 @@
 #include <sys/types.h>
 #include <sys/uio.h>
 #include "winsock2.h"
+#include "winnt.h"
 #include "request.h"
 #include "unicode.h"
 
@@ -26,6 +27,17 @@
     fputc( '}', stderr );
 }
 
+static void dump_uints( const int *ptr, int len )
+{
+    fputc( '{', stderr );
+    while (len)
+    {
+        fprintf( stderr, "%08x", *ptr++ );
+        if (--len) fputc( ',', stderr );
+    }
+    fputc( '}', stderr );
+}
+
 static void dump_bytes( const unsigned char *ptr, int len )
 {
     fputc( '{', stderr );
@@ -44,15 +56,103 @@
     fputc( '\"', stderr );
 }
 
+static void dump_path_t( const path_t *path )
+{
+    dump_unicode_string( *path );
+}
+
+static void dump_context( const CONTEXT *context )
+{
+#ifdef __i386__
+    fprintf( stderr, "{flags=%08lx,eax=%08lx,ebx=%08lx,ecx=%08lx,edx=%08lx,esi=%08lx,edi=%08lx,"
+             "ebp=%08lx,eip=%08lx,esp=%08lx,eflags=%08lx,cs=%04lx,ds=%04lx,es=%04lx,"
+             "fs=%04lx,gs=%04lx,dr0=%08lx,dr1=%08lx,dr2=%08lx,dr3=%08lx,dr6=%08lx,dr7=%08lx,",
+             context->ContextFlags, context->Eax, context->Ebx, context->Ecx, context->Edx,
+             context->Esi, context->Edi, context->Ebp, context->Eip, context->Esp, context->EFlags,
+             context->SegCs, context->SegDs, context->SegEs, context->SegFs, context->SegGs,
+             context->Dr0, context->Dr1, context->Dr2, context->Dr3, context->Dr6, context->Dr7 );
+    fprintf( stderr, "float=" );
+    dump_uints( (int *)&context->FloatSave, sizeof(context->FloatSave) / sizeof(int) );
+    fprintf( stderr, "}" );
+#else
+    dump_uints( (int *)context, sizeof(*context) / sizeof(int) );
+#endif
+}
+
+static void dump_debug_event_t( const debug_event_t *event )
+{
+    int i;
+    switch(event->code)
+    {
+    case EXCEPTION_DEBUG_EVENT:
+        fprintf( stderr, "{exception,code=%x,flags=%x,rec=%p,addr=%p,params={",
+                 event->info.exception.code, event->info.exception.flags,
+                 event->info.exception.record, event->info.exception.addr );
+        for (i = 0; i < event->info.exception.nb_params; i++)
+        {
+            if (i) fputc( ',', stderr );
+            fprintf( stderr, "%x", event->info.exception.params[i] );
+        }
+        fprintf( stderr, "},first_chance=%d,context=", event->info.exception.first_chance );
+        dump_context( &event->info.exception.context );
+        fputc( '}', stderr );
+        break;
+    case CREATE_THREAD_DEBUG_EVENT:
+        fprintf( stderr, "{create_thread,thread=%d,teb=%p,start=%p}",
+                 event->info.create_thread.handle, event->info.create_thread.teb,
+                 event->info.create_thread.start );
+        break;
+    case CREATE_PROCESS_DEBUG_EVENT:
+        fprintf( stderr, "{create_process,file=%d,process=%d,thread=%d,base=%p,offset=%d,"
+                         "size=%d,teb=%p,start=%p,name=%p,unicode=%d}",
+                 event->info.create_process.file, event->info.create_process.process,
+                 event->info.create_process.thread, event->info.create_process.base,
+                 event->info.create_process.dbg_offset, event->info.create_process.dbg_size,
+                 event->info.create_process.teb, event->info.create_process.start,
+                 event->info.create_process.name, event->info.create_process.unicode );
+        break;
+    case EXIT_THREAD_DEBUG_EVENT:
+        fprintf( stderr, "{exit_thread,code=%d}", event->info.exit.exit_code );
+        break;
+    case EXIT_PROCESS_DEBUG_EVENT:
+        fprintf( stderr, "{exit_process,code=%d}", event->info.exit.exit_code );
+        break;
+    case LOAD_DLL_DEBUG_EVENT:
+        fprintf( stderr, "{load_dll,file=%d,base=%p,offset=%d,size=%d,name=%p,unicode=%d}",
+                 event->info.load_dll.handle, event->info.load_dll.base,
+                 event->info.load_dll.dbg_offset, event->info.load_dll.dbg_size,
+                 event->info.load_dll.name, event->info.load_dll.unicode );
+        break;
+    case UNLOAD_DLL_DEBUG_EVENT:
+        fprintf( stderr, "{unload_dll,base=%p}", event->info.unload_dll.base );
+        break;
+    case OUTPUT_DEBUG_STRING_EVENT:
+        fprintf( stderr, "{output_string,data=%p,unicode=%d,len=%d}",
+                 event->info.output_string.string, event->info.output_string.unicode,
+                 event->info.output_string.length );
+        break;
+    case RIP_EVENT:
+        fprintf( stderr, "{rip,err=%d,type=%d}",
+                 event->info.rip_info.error, event->info.rip_info.type );
+        break;
+    case 0:  /* zero is the code returned on timeouts */
+        fprintf( stderr, "{}" );
+        break;
+    default:
+        fprintf( stderr, "{code=??? (%d)}", event->code );
+        break;
+    }
+}
+
 
 /* dumping for functions for requests that have a variable part */
 
-static void dump_varargs_select_request( struct select_request *req )
+static void dump_varargs_select_request( const struct select_request *req )
 {
     dump_ints( req->handles, req->count );
 }
 
-static void dump_varargs_get_apcs_reply( struct get_apcs_request *req )
+static void dump_varargs_get_apcs_reply( const struct get_apcs_request *req )
 {
     int i;
     for (i = 0; i < 2 * req->count; i++)
@@ -60,34 +160,34 @@
     fprintf( stderr, "}" );
 }
 
-static void dump_varargs_get_socket_event_reply( struct get_socket_event_request *req )
+static void dump_varargs_get_socket_event_reply( const struct get_socket_event_request *req )
 {
     dump_ints( req->errors, FD_MAX_EVENTS );
 }
 
-static void dump_varargs_read_process_memory_reply( struct read_process_memory_request *req )
+static void dump_varargs_read_process_memory_reply( const struct read_process_memory_request *req )
 {
     int count = MIN( req->len, get_req_size( req->data, sizeof(int) ) );
     dump_bytes( (unsigned char *)req->data, count * sizeof(int) );
 }
 
-static void dump_varargs_write_process_memory_request( struct write_process_memory_request *req )
+static void dump_varargs_write_process_memory_request( const struct write_process_memory_request *req )
 {
     int count = MIN( req->len, get_req_size( req->data, sizeof(int) ) );
     dump_bytes( (unsigned char *)req->data, count * sizeof(int) );
 }
 
-static void dump_varargs_set_key_value_request( struct set_key_value_request *req )
+static void dump_varargs_set_key_value_request( const struct set_key_value_request *req )
 {
     dump_bytes( req->data, req->len );
 }
 
-static void dump_varargs_get_key_value_reply( struct get_key_value_request *req )
+static void dump_varargs_get_key_value_reply( const struct get_key_value_request *req )
 {
     dump_bytes( req->data, req->len );
 }
 
-static void dump_varargs_enum_key_value_reply( struct enum_key_value_request *req )
+static void dump_varargs_enum_key_value_reply( const struct enum_key_value_request *req )
 {
     dump_bytes( req->data, req->len );
 }
@@ -97,7 +197,7 @@
 /* Everything below this line is generated automatically by tools/make_requests */
 /* ### make_requests begin ### */
 
-static void dump_new_process_request( struct new_process_request *req )
+static void dump_new_process_request( const struct new_process_request *req )
 {
     fprintf( stderr, " inherit=%d,", req->inherit );
     fprintf( stderr, " inherit_all=%d,", req->inherit_all );
@@ -112,35 +212,35 @@
     fprintf( stderr, " cmdline=\"%s\"", req->cmdline );
 }
 
-static void dump_new_process_reply( struct new_process_request *req )
+static void dump_new_process_reply( const struct new_process_request *req )
 {
     fprintf( stderr, " pid=%p,", req->pid );
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_new_thread_request( struct new_thread_request *req )
+static void dump_new_thread_request( const struct new_thread_request *req )
 {
     fprintf( stderr, " pid=%p,", req->pid );
     fprintf( stderr, " suspend=%d,", req->suspend );
     fprintf( stderr, " inherit=%d", req->inherit );
 }
 
-static void dump_new_thread_reply( struct new_thread_request *req )
+static void dump_new_thread_reply( const struct new_thread_request *req )
 {
     fprintf( stderr, " tid=%p,", req->tid );
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_set_debug_request( struct set_debug_request *req )
+static void dump_set_debug_request( const struct set_debug_request *req )
 {
     fprintf( stderr, " level=%d", req->level );
 }
 
-static void dump_init_process_request( struct init_process_request *req )
+static void dump_init_process_request( const struct init_process_request *req )
 {
 }
 
-static void dump_init_process_reply( struct init_process_request *req )
+static void dump_init_process_reply( const struct init_process_request *req )
 {
     fprintf( stderr, " start_flags=%d,", req->start_flags );
     fprintf( stderr, " hstdin=%d,", req->hstdin );
@@ -151,46 +251,46 @@
     fprintf( stderr, " cmdline=\"%s\"", req->cmdline );
 }
 
-static void dump_init_process_done_request( struct init_process_done_request *req )
+static void dump_init_process_done_request( const struct init_process_done_request *req )
 {
     fprintf( stderr, " dummy=%d", req->dummy );
 }
 
-static void dump_init_thread_request( struct init_thread_request *req )
+static void dump_init_thread_request( const struct init_thread_request *req )
 {
     fprintf( stderr, " unix_pid=%d,", req->unix_pid );
     fprintf( stderr, " teb=%p", req->teb );
 }
 
-static void dump_init_thread_reply( struct init_thread_request *req )
+static void dump_init_thread_reply( const struct init_thread_request *req )
 {
     fprintf( stderr, " pid=%p,", req->pid );
     fprintf( stderr, " tid=%p", req->tid );
 }
 
-static void dump_get_thread_buffer_request( struct get_thread_buffer_request *req )
+static void dump_get_thread_buffer_request( const struct get_thread_buffer_request *req )
 {
     fprintf( stderr, " dummy=%d", req->dummy );
 }
 
-static void dump_terminate_process_request( struct terminate_process_request *req )
+static void dump_terminate_process_request( const struct terminate_process_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " exit_code=%d", req->exit_code );
 }
 
-static void dump_terminate_thread_request( struct terminate_thread_request *req )
+static void dump_terminate_thread_request( const struct terminate_thread_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " exit_code=%d", req->exit_code );
 }
 
-static void dump_get_process_info_request( struct get_process_info_request *req )
+static void dump_get_process_info_request( const struct get_process_info_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_get_process_info_reply( struct get_process_info_request *req )
+static void dump_get_process_info_reply( const struct get_process_info_request *req )
 {
     fprintf( stderr, " pid=%p,", req->pid );
     fprintf( stderr, " exit_code=%d,", req->exit_code );
@@ -199,7 +299,7 @@
     fprintf( stderr, " system_affinity=%d", req->system_affinity );
 }
 
-static void dump_set_process_info_request( struct set_process_info_request *req )
+static void dump_set_process_info_request( const struct set_process_info_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " mask=%d,", req->mask );
@@ -207,19 +307,19 @@
     fprintf( stderr, " affinity=%d", req->affinity );
 }
 
-static void dump_get_thread_info_request( struct get_thread_info_request *req )
+static void dump_get_thread_info_request( const struct get_thread_info_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_get_thread_info_reply( struct get_thread_info_request *req )
+static void dump_get_thread_info_reply( const struct get_thread_info_request *req )
 {
     fprintf( stderr, " tid=%p,", req->tid );
     fprintf( stderr, " exit_code=%d,", req->exit_code );
     fprintf( stderr, " priority=%d", req->priority );
 }
 
-static void dump_set_thread_info_request( struct set_thread_info_request *req )
+static void dump_set_thread_info_request( const struct set_thread_info_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " mask=%d,", req->mask );
@@ -227,72 +327,72 @@
     fprintf( stderr, " affinity=%d", req->affinity );
 }
 
-static void dump_suspend_thread_request( struct suspend_thread_request *req )
+static void dump_suspend_thread_request( const struct suspend_thread_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_suspend_thread_reply( struct suspend_thread_request *req )
+static void dump_suspend_thread_reply( const struct suspend_thread_request *req )
 {
     fprintf( stderr, " count=%d", req->count );
 }
 
-static void dump_resume_thread_request( struct resume_thread_request *req )
+static void dump_resume_thread_request( const struct resume_thread_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_resume_thread_reply( struct resume_thread_request *req )
+static void dump_resume_thread_reply( const struct resume_thread_request *req )
 {
     fprintf( stderr, " count=%d", req->count );
 }
 
-static void dump_debugger_request( struct debugger_request *req )
+static void dump_debugger_request( const struct debugger_request *req )
 {
     fprintf( stderr, " op=%d", req->op );
 }
 
-static void dump_queue_apc_request( struct queue_apc_request *req )
+static void dump_queue_apc_request( const struct queue_apc_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " func=%p,", req->func );
     fprintf( stderr, " param=%p", req->param );
 }
 
-static void dump_get_apcs_request( struct get_apcs_request *req )
+static void dump_get_apcs_request( const struct get_apcs_request *req )
 {
 }
 
-static void dump_get_apcs_reply( struct get_apcs_request *req )
+static void dump_get_apcs_reply( const struct get_apcs_request *req )
 {
     fprintf( stderr, " count=%d,", req->count );
     fprintf( stderr, " apcs=" );
     dump_varargs_get_apcs_reply( req );
 }
 
-static void dump_close_handle_request( struct close_handle_request *req )
+static void dump_close_handle_request( const struct close_handle_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_get_handle_info_request( struct get_handle_info_request *req )
+static void dump_get_handle_info_request( const struct get_handle_info_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_get_handle_info_reply( struct get_handle_info_request *req )
+static void dump_get_handle_info_reply( const struct get_handle_info_request *req )
 {
     fprintf( stderr, " flags=%d", req->flags );
 }
 
-static void dump_set_handle_info_request( struct set_handle_info_request *req )
+static void dump_set_handle_info_request( const struct set_handle_info_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " flags=%d,", req->flags );
     fprintf( stderr, " mask=%d", req->mask );
 }
 
-static void dump_dup_handle_request( struct dup_handle_request *req )
+static void dump_dup_handle_request( const struct dup_handle_request *req )
 {
     fprintf( stderr, " src_process=%d,", req->src_process );
     fprintf( stderr, " src_handle=%d,", req->src_handle );
@@ -302,24 +402,24 @@
     fprintf( stderr, " options=%d", req->options );
 }
 
-static void dump_dup_handle_reply( struct dup_handle_request *req )
+static void dump_dup_handle_reply( const struct dup_handle_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_open_process_request( struct open_process_request *req )
+static void dump_open_process_request( const struct open_process_request *req )
 {
     fprintf( stderr, " pid=%p,", req->pid );
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d", req->inherit );
 }
 
-static void dump_open_process_reply( struct open_process_request *req )
+static void dump_open_process_reply( const struct open_process_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_select_request( struct select_request *req )
+static void dump_select_request( const struct select_request *req )
 {
     fprintf( stderr, " count=%d,", req->count );
     fprintf( stderr, " flags=%d,", req->flags );
@@ -328,12 +428,12 @@
     dump_varargs_select_request( req );
 }
 
-static void dump_select_reply( struct select_request *req )
+static void dump_select_reply( const struct select_request *req )
 {
     fprintf( stderr, " signaled=%d", req->signaled );
 }
 
-static void dump_create_event_request( struct create_event_request *req )
+static void dump_create_event_request( const struct create_event_request *req )
 {
     fprintf( stderr, " manual_reset=%d,", req->manual_reset );
     fprintf( stderr, " initial_state=%d,", req->initial_state );
@@ -342,18 +442,18 @@
     dump_unicode_string( req->name );
 }
 
-static void dump_create_event_reply( struct create_event_request *req )
+static void dump_create_event_reply( const struct create_event_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_event_op_request( struct event_op_request *req )
+static void dump_event_op_request( const struct event_op_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " op=%d", req->op );
 }
 
-static void dump_open_event_request( struct open_event_request *req )
+static void dump_open_event_request( const struct open_event_request *req )
 {
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d,", req->inherit );
@@ -361,12 +461,12 @@
     dump_unicode_string( req->name );
 }
 
-static void dump_open_event_reply( struct open_event_request *req )
+static void dump_open_event_reply( const struct open_event_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_create_mutex_request( struct create_mutex_request *req )
+static void dump_create_mutex_request( const struct create_mutex_request *req )
 {
     fprintf( stderr, " owned=%d,", req->owned );
     fprintf( stderr, " inherit=%d,", req->inherit );
@@ -374,17 +474,17 @@
     dump_unicode_string( req->name );
 }
 
-static void dump_create_mutex_reply( struct create_mutex_request *req )
+static void dump_create_mutex_reply( const struct create_mutex_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_release_mutex_request( struct release_mutex_request *req )
+static void dump_release_mutex_request( const struct release_mutex_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_open_mutex_request( struct open_mutex_request *req )
+static void dump_open_mutex_request( const struct open_mutex_request *req )
 {
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d,", req->inherit );
@@ -392,12 +492,12 @@
     dump_unicode_string( req->name );
 }
 
-static void dump_open_mutex_reply( struct open_mutex_request *req )
+static void dump_open_mutex_reply( const struct open_mutex_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_create_semaphore_request( struct create_semaphore_request *req )
+static void dump_create_semaphore_request( const struct create_semaphore_request *req )
 {
     fprintf( stderr, " initial=%08x,", req->initial );
     fprintf( stderr, " max=%08x,", req->max );
@@ -406,23 +506,23 @@
     dump_unicode_string( req->name );
 }
 
-static void dump_create_semaphore_reply( struct create_semaphore_request *req )
+static void dump_create_semaphore_reply( const struct create_semaphore_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_release_semaphore_request( struct release_semaphore_request *req )
+static void dump_release_semaphore_request( const struct release_semaphore_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " count=%08x", req->count );
 }
 
-static void dump_release_semaphore_reply( struct release_semaphore_request *req )
+static void dump_release_semaphore_reply( const struct release_semaphore_request *req )
 {
     fprintf( stderr, " prev_count=%08x", req->prev_count );
 }
 
-static void dump_open_semaphore_request( struct open_semaphore_request *req )
+static void dump_open_semaphore_request( const struct open_semaphore_request *req )
 {
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d,", req->inherit );
@@ -430,12 +530,12 @@
     dump_unicode_string( req->name );
 }
 
-static void dump_open_semaphore_reply( struct open_semaphore_request *req )
+static void dump_open_semaphore_reply( const struct open_semaphore_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_create_file_request( struct create_file_request *req )
+static void dump_create_file_request( const struct create_file_request *req )
 {
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d,", req->inherit );
@@ -445,32 +545,32 @@
     fprintf( stderr, " name=\"%s\"", req->name );
 }
 
-static void dump_create_file_reply( struct create_file_request *req )
+static void dump_create_file_reply( const struct create_file_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_alloc_file_handle_request( struct alloc_file_handle_request *req )
+static void dump_alloc_file_handle_request( const struct alloc_file_handle_request *req )
 {
     fprintf( stderr, " access=%08x", req->access );
 }
 
-static void dump_alloc_file_handle_reply( struct alloc_file_handle_request *req )
+static void dump_alloc_file_handle_reply( const struct alloc_file_handle_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_get_read_fd_request( struct get_read_fd_request *req )
+static void dump_get_read_fd_request( const struct get_read_fd_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_get_write_fd_request( struct get_write_fd_request *req )
+static void dump_get_write_fd_request( const struct get_write_fd_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_set_file_pointer_request( struct set_file_pointer_request *req )
+static void dump_set_file_pointer_request( const struct set_file_pointer_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " low=%d,", req->low );
@@ -478,35 +578,35 @@
     fprintf( stderr, " whence=%d", req->whence );
 }
 
-static void dump_set_file_pointer_reply( struct set_file_pointer_request *req )
+static void dump_set_file_pointer_reply( const struct set_file_pointer_request *req )
 {
     fprintf( stderr, " new_low=%d,", req->new_low );
     fprintf( stderr, " new_high=%d", req->new_high );
 }
 
-static void dump_truncate_file_request( struct truncate_file_request *req )
+static void dump_truncate_file_request( const struct truncate_file_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_set_file_time_request( struct set_file_time_request *req )
+static void dump_set_file_time_request( const struct set_file_time_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " access_time=%ld,", req->access_time );
     fprintf( stderr, " write_time=%ld", req->write_time );
 }
 
-static void dump_flush_file_request( struct flush_file_request *req )
+static void dump_flush_file_request( const struct flush_file_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_get_file_info_request( struct get_file_info_request *req )
+static void dump_get_file_info_request( const struct get_file_info_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_get_file_info_reply( struct get_file_info_request *req )
+static void dump_get_file_info_reply( const struct get_file_info_request *req )
 {
     fprintf( stderr, " type=%d,", req->type );
     fprintf( stderr, " attr=%d,", req->attr );
@@ -520,7 +620,7 @@
     fprintf( stderr, " serial=%08x", req->serial );
 }
 
-static void dump_lock_file_request( struct lock_file_request *req )
+static void dump_lock_file_request( const struct lock_file_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " offset_low=%08x,", req->offset_low );
@@ -529,7 +629,7 @@
     fprintf( stderr, " count_high=%08x", req->count_high );
 }
 
-static void dump_unlock_file_request( struct unlock_file_request *req )
+static void dump_unlock_file_request( const struct unlock_file_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " offset_low=%08x,", req->offset_low );
@@ -538,18 +638,18 @@
     fprintf( stderr, " count_high=%08x", req->count_high );
 }
 
-static void dump_create_pipe_request( struct create_pipe_request *req )
+static void dump_create_pipe_request( const struct create_pipe_request *req )
 {
     fprintf( stderr, " inherit=%d", req->inherit );
 }
 
-static void dump_create_pipe_reply( struct create_pipe_request *req )
+static void dump_create_pipe_reply( const struct create_pipe_request *req )
 {
     fprintf( stderr, " handle_read=%d,", req->handle_read );
     fprintf( stderr, " handle_write=%d", req->handle_write );
 }
 
-static void dump_create_socket_request( struct create_socket_request *req )
+static void dump_create_socket_request( const struct create_socket_request *req )
 {
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d,", req->inherit );
@@ -558,38 +658,38 @@
     fprintf( stderr, " protocol=%d", req->protocol );
 }
 
-static void dump_create_socket_reply( struct create_socket_request *req )
+static void dump_create_socket_reply( const struct create_socket_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_accept_socket_request( struct accept_socket_request *req )
+static void dump_accept_socket_request( const struct accept_socket_request *req )
 {
     fprintf( stderr, " lhandle=%d,", req->lhandle );
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d", req->inherit );
 }
 
-static void dump_accept_socket_reply( struct accept_socket_request *req )
+static void dump_accept_socket_reply( const struct accept_socket_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_set_socket_event_request( struct set_socket_event_request *req )
+static void dump_set_socket_event_request( const struct set_socket_event_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " mask=%08x,", req->mask );
     fprintf( stderr, " event=%d", req->event );
 }
 
-static void dump_get_socket_event_request( struct get_socket_event_request *req )
+static void dump_get_socket_event_request( const struct get_socket_event_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " service=%d,", req->service );
     fprintf( stderr, " s_event=%d", req->s_event );
 }
 
-static void dump_get_socket_event_reply( struct get_socket_event_request *req )
+static void dump_get_socket_event_reply( const struct get_socket_event_request *req )
 {
     fprintf( stderr, " mask=%08x,", req->mask );
     fprintf( stderr, " pmask=%08x,", req->pmask );
@@ -598,7 +698,7 @@
     dump_varargs_get_socket_event_reply( req );
 }
 
-static void dump_enable_socket_event_request( struct enable_socket_event_request *req )
+static void dump_enable_socket_event_request( const struct enable_socket_event_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " mask=%08x,", req->mask );
@@ -606,59 +706,59 @@
     fprintf( stderr, " cstate=%08x", req->cstate );
 }
 
-static void dump_alloc_console_request( struct alloc_console_request *req )
+static void dump_alloc_console_request( const struct alloc_console_request *req )
 {
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d", req->inherit );
 }
 
-static void dump_alloc_console_reply( struct alloc_console_request *req )
+static void dump_alloc_console_reply( const struct alloc_console_request *req )
 {
     fprintf( stderr, " handle_in=%d,", req->handle_in );
     fprintf( stderr, " handle_out=%d", req->handle_out );
 }
 
-static void dump_free_console_request( struct free_console_request *req )
+static void dump_free_console_request( const struct free_console_request *req )
 {
     fprintf( stderr, " dummy=%d", req->dummy );
 }
 
-static void dump_open_console_request( struct open_console_request *req )
+static void dump_open_console_request( const struct open_console_request *req )
 {
     fprintf( stderr, " output=%d,", req->output );
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d", req->inherit );
 }
 
-static void dump_open_console_reply( struct open_console_request *req )
+static void dump_open_console_reply( const struct open_console_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_set_console_fd_request( struct set_console_fd_request *req )
+static void dump_set_console_fd_request( const struct set_console_fd_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " file_handle=%d,", req->file_handle );
     fprintf( stderr, " pid=%d", req->pid );
 }
 
-static void dump_get_console_mode_request( struct get_console_mode_request *req )
+static void dump_get_console_mode_request( const struct get_console_mode_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_get_console_mode_reply( struct get_console_mode_request *req )
+static void dump_get_console_mode_reply( const struct get_console_mode_request *req )
 {
     fprintf( stderr, " mode=%d", req->mode );
 }
 
-static void dump_set_console_mode_request( struct set_console_mode_request *req )
+static void dump_set_console_mode_request( const struct set_console_mode_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " mode=%d", req->mode );
 }
 
-static void dump_set_console_info_request( struct set_console_info_request *req )
+static void dump_set_console_info_request( const struct set_console_info_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " mask=%d,", req->mask );
@@ -667,12 +767,12 @@
     fprintf( stderr, " title=\"%s\"", req->title );
 }
 
-static void dump_get_console_info_request( struct get_console_info_request *req )
+static void dump_get_console_info_request( const struct get_console_info_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_get_console_info_reply( struct get_console_info_request *req )
+static void dump_get_console_info_reply( const struct get_console_info_request *req )
 {
     fprintf( stderr, " cursor_size=%d,", req->cursor_size );
     fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
@@ -680,41 +780,41 @@
     fprintf( stderr, " title=\"%s\"", req->title );
 }
 
-static void dump_write_console_input_request( struct write_console_input_request *req )
+static void dump_write_console_input_request( const struct write_console_input_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " count=%d", req->count );
 }
 
-static void dump_write_console_input_reply( struct write_console_input_request *req )
+static void dump_write_console_input_reply( const struct write_console_input_request *req )
 {
     fprintf( stderr, " written=%d", req->written );
 }
 
-static void dump_read_console_input_request( struct read_console_input_request *req )
+static void dump_read_console_input_request( const struct read_console_input_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " count=%d,", req->count );
     fprintf( stderr, " flush=%d", req->flush );
 }
 
-static void dump_read_console_input_reply( struct read_console_input_request *req )
+static void dump_read_console_input_reply( const struct read_console_input_request *req )
 {
     fprintf( stderr, " read=%d", req->read );
 }
 
-static void dump_create_change_notification_request( struct create_change_notification_request *req )
+static void dump_create_change_notification_request( const struct create_change_notification_request *req )
 {
     fprintf( stderr, " subtree=%d,", req->subtree );
     fprintf( stderr, " filter=%d", req->filter );
 }
 
-static void dump_create_change_notification_reply( struct create_change_notification_request *req )
+static void dump_create_change_notification_reply( const struct create_change_notification_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_create_mapping_request( struct create_mapping_request *req )
+static void dump_create_mapping_request( const struct create_mapping_request *req )
 {
     fprintf( stderr, " size_high=%d,", req->size_high );
     fprintf( stderr, " size_low=%d,", req->size_low );
@@ -725,12 +825,12 @@
     dump_unicode_string( req->name );
 }
 
-static void dump_create_mapping_reply( struct create_mapping_request *req )
+static void dump_create_mapping_reply( const struct create_mapping_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_open_mapping_request( struct open_mapping_request *req )
+static void dump_open_mapping_request( const struct open_mapping_request *req )
 {
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d,", req->inherit );
@@ -738,107 +838,109 @@
     dump_unicode_string( req->name );
 }
 
-static void dump_open_mapping_reply( struct open_mapping_request *req )
+static void dump_open_mapping_reply( const struct open_mapping_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_get_mapping_info_request( struct get_mapping_info_request *req )
+static void dump_get_mapping_info_request( const struct get_mapping_info_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_get_mapping_info_reply( struct get_mapping_info_request *req )
+static void dump_get_mapping_info_reply( const struct get_mapping_info_request *req )
 {
     fprintf( stderr, " size_high=%d,", req->size_high );
     fprintf( stderr, " size_low=%d,", req->size_low );
     fprintf( stderr, " protect=%d", req->protect );
 }
 
-static void dump_create_device_request( struct create_device_request *req )
+static void dump_create_device_request( const struct create_device_request *req )
 {
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d,", req->inherit );
     fprintf( stderr, " id=%d", req->id );
 }
 
-static void dump_create_device_reply( struct create_device_request *req )
+static void dump_create_device_reply( const struct create_device_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_create_snapshot_request( struct create_snapshot_request *req )
+static void dump_create_snapshot_request( const struct create_snapshot_request *req )
 {
     fprintf( stderr, " inherit=%d,", req->inherit );
     fprintf( stderr, " flags=%d", req->flags );
 }
 
-static void dump_create_snapshot_reply( struct create_snapshot_request *req )
+static void dump_create_snapshot_reply( const struct create_snapshot_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_next_process_request( struct next_process_request *req )
+static void dump_next_process_request( const struct next_process_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " reset=%d", req->reset );
 }
 
-static void dump_next_process_reply( struct next_process_request *req )
+static void dump_next_process_reply( const struct next_process_request *req )
 {
     fprintf( stderr, " pid=%p,", req->pid );
     fprintf( stderr, " threads=%d,", req->threads );
     fprintf( stderr, " priority=%d", req->priority );
 }
 
-static void dump_wait_debug_event_request( struct wait_debug_event_request *req )
+static void dump_wait_debug_event_request( const struct wait_debug_event_request *req )
 {
     fprintf( stderr, " timeout=%d", req->timeout );
 }
 
-static void dump_wait_debug_event_reply( struct wait_debug_event_request *req )
+static void dump_wait_debug_event_reply( const struct wait_debug_event_request *req )
 {
-    fprintf( stderr, " code=%d,", req->code );
     fprintf( stderr, " pid=%p,", req->pid );
-    fprintf( stderr, " tid=%p", req->tid );
+    fprintf( stderr, " tid=%p,", req->tid );
+    fprintf( stderr, " event=" );
+    dump_debug_event_t( &req->event );
 }
 
-static void dump_send_debug_event_request( struct send_debug_event_request *req )
+static void dump_send_debug_event_request( const struct send_debug_event_request *req )
 {
-    fprintf( stderr, " code=%d", req->code );
+    fprintf( stderr, " event=" );
+    dump_debug_event_t( &req->event );
 }
 
-static void dump_send_debug_event_reply( struct send_debug_event_request *req )
+static void dump_send_debug_event_reply( const struct send_debug_event_request *req )
 {
     fprintf( stderr, " status=%d", req->status );
 }
 
-static void dump_continue_debug_event_request( struct continue_debug_event_request *req )
+static void dump_continue_debug_event_request( const struct continue_debug_event_request *req )
 {
     fprintf( stderr, " pid=%p,", req->pid );
     fprintf( stderr, " tid=%p,", req->tid );
     fprintf( stderr, " status=%d", req->status );
 }
 
-static void dump_debug_process_request( struct debug_process_request *req )
+static void dump_debug_process_request( const struct debug_process_request *req )
 {
     fprintf( stderr, " pid=%p", req->pid );
 }
 
-static void dump_read_process_memory_request( struct read_process_memory_request *req )
+static void dump_read_process_memory_request( const struct read_process_memory_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " addr=%p,", req->addr );
     fprintf( stderr, " len=%d", req->len );
 }
 
-static void dump_read_process_memory_reply( struct read_process_memory_request *req )
+static void dump_read_process_memory_reply( const struct read_process_memory_request *req )
 {
     fprintf( stderr, " data=" );
     dump_varargs_read_process_memory_reply( req );
 }
 
-static void dump_write_process_memory_request( struct write_process_memory_request *req )
+static void dump_write_process_memory_request( const struct write_process_memory_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " addr=%p,", req->addr );
@@ -849,72 +951,72 @@
     dump_varargs_write_process_memory_request( req );
 }
 
-static void dump_create_key_request( struct create_key_request *req )
+static void dump_create_key_request( const struct create_key_request *req )
 {
     fprintf( stderr, " parent=%d,", req->parent );
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " options=%08x,", req->options );
     fprintf( stderr, " modif=%ld,", req->modif );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req->name );
+    dump_path_t( &req->name );
     fprintf( stderr, "," );
     fprintf( stderr, " class=" );
     dump_unicode_string( req->class );
 }
 
-static void dump_create_key_reply( struct create_key_request *req )
+static void dump_create_key_reply( const struct create_key_request *req )
 {
     fprintf( stderr, " hkey=%d,", req->hkey );
     fprintf( stderr, " created=%d", req->created );
 }
 
-static void dump_open_key_request( struct open_key_request *req )
+static void dump_open_key_request( const struct open_key_request *req )
 {
     fprintf( stderr, " parent=%d,", req->parent );
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req->name );
+    dump_path_t( &req->name );
 }
 
-static void dump_open_key_reply( struct open_key_request *req )
+static void dump_open_key_reply( const struct open_key_request *req )
 {
     fprintf( stderr, " hkey=%d", req->hkey );
 }
 
-static void dump_delete_key_request( struct delete_key_request *req )
+static void dump_delete_key_request( const struct delete_key_request *req )
 {
     fprintf( stderr, " hkey=%d,", req->hkey );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req->name );
+    dump_path_t( &req->name );
 }
 
-static void dump_close_key_request( struct close_key_request *req )
+static void dump_close_key_request( const struct close_key_request *req )
 {
     fprintf( stderr, " hkey=%d", req->hkey );
 }
 
-static void dump_enum_key_request( struct enum_key_request *req )
+static void dump_enum_key_request( const struct enum_key_request *req )
 {
     fprintf( stderr, " hkey=%d,", req->hkey );
     fprintf( stderr, " index=%d", req->index );
 }
 
-static void dump_enum_key_reply( struct enum_key_request *req )
+static void dump_enum_key_reply( const struct enum_key_request *req )
 {
     fprintf( stderr, " modif=%ld,", req->modif );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req->name );
+    dump_path_t( &req->name );
     fprintf( stderr, "," );
     fprintf( stderr, " class=" );
     dump_unicode_string( req->class );
 }
 
-static void dump_query_key_info_request( struct query_key_info_request *req )
+static void dump_query_key_info_request( const struct query_key_info_request *req )
 {
     fprintf( stderr, " hkey=%d", req->hkey );
 }
 
-static void dump_query_key_info_reply( struct query_key_info_request *req )
+static void dump_query_key_info_reply( const struct query_key_info_request *req )
 {
     fprintf( stderr, " subkeys=%d,", req->subkeys );
     fprintf( stderr, " max_subkey=%d,", req->max_subkey );
@@ -924,32 +1026,32 @@
     fprintf( stderr, " max_data=%d,", req->max_data );
     fprintf( stderr, " modif=%ld,", req->modif );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req->name );
+    dump_path_t( &req->name );
     fprintf( stderr, "," );
     fprintf( stderr, " class=" );
     dump_unicode_string( req->class );
 }
 
-static void dump_set_key_value_request( struct set_key_value_request *req )
+static void dump_set_key_value_request( const struct set_key_value_request *req )
 {
     fprintf( stderr, " hkey=%d,", req->hkey );
     fprintf( stderr, " type=%d,", req->type );
     fprintf( stderr, " len=%d,", req->len );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req->name );
+    dump_path_t( &req->name );
     fprintf( stderr, "," );
     fprintf( stderr, " data=" );
     dump_varargs_set_key_value_request( req );
 }
 
-static void dump_get_key_value_request( struct get_key_value_request *req )
+static void dump_get_key_value_request( const struct get_key_value_request *req )
 {
     fprintf( stderr, " hkey=%d,", req->hkey );
     fprintf( stderr, " name=" );
     dump_unicode_string( req->name );
 }
 
-static void dump_get_key_value_reply( struct get_key_value_request *req )
+static void dump_get_key_value_reply( const struct get_key_value_request *req )
 {
     fprintf( stderr, " type=%d,", req->type );
     fprintf( stderr, " len=%d,", req->len );
@@ -957,52 +1059,52 @@
     dump_varargs_get_key_value_reply( req );
 }
 
-static void dump_enum_key_value_request( struct enum_key_value_request *req )
+static void dump_enum_key_value_request( const struct enum_key_value_request *req )
 {
     fprintf( stderr, " hkey=%d,", req->hkey );
     fprintf( stderr, " index=%d", req->index );
 }
 
-static void dump_enum_key_value_reply( struct enum_key_value_request *req )
+static void dump_enum_key_value_reply( const struct enum_key_value_request *req )
 {
     fprintf( stderr, " type=%d,", req->type );
     fprintf( stderr, " len=%d,", req->len );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req->name );
+    dump_path_t( &req->name );
     fprintf( stderr, "," );
     fprintf( stderr, " data=" );
     dump_varargs_enum_key_value_reply( req );
 }
 
-static void dump_delete_key_value_request( struct delete_key_value_request *req )
+static void dump_delete_key_value_request( const struct delete_key_value_request *req )
 {
     fprintf( stderr, " hkey=%d,", req->hkey );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req->name );
+    dump_path_t( &req->name );
 }
 
-static void dump_load_registry_request( struct load_registry_request *req )
+static void dump_load_registry_request( const struct load_registry_request *req )
 {
     fprintf( stderr, " hkey=%d,", req->hkey );
     fprintf( stderr, " file=%d,", req->file );
     fprintf( stderr, " name=" );
-    dump_unicode_string( req->name );
+    dump_path_t( &req->name );
 }
 
-static void dump_save_registry_request( struct save_registry_request *req )
+static void dump_save_registry_request( const struct save_registry_request *req )
 {
     fprintf( stderr, " hkey=%d,", req->hkey );
     fprintf( stderr, " file=%d", req->file );
 }
 
-static void dump_set_registry_levels_request( struct set_registry_levels_request *req )
+static void dump_set_registry_levels_request( const struct set_registry_levels_request *req )
 {
     fprintf( stderr, " current=%d,", req->current );
     fprintf( stderr, " saving=%d,", req->saving );
     fprintf( stderr, " version=%d", req->version );
 }
 
-static void dump_create_timer_request( struct create_timer_request *req )
+static void dump_create_timer_request( const struct create_timer_request *req )
 {
     fprintf( stderr, " inherit=%d,", req->inherit );
     fprintf( stderr, " manual=%d,", req->manual );
@@ -1010,12 +1112,12 @@
     dump_unicode_string( req->name );
 }
 
-static void dump_create_timer_reply( struct create_timer_request *req )
+static void dump_create_timer_reply( const struct create_timer_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_open_timer_request( struct open_timer_request *req )
+static void dump_open_timer_request( const struct open_timer_request *req )
 {
     fprintf( stderr, " access=%08x,", req->access );
     fprintf( stderr, " inherit=%d,", req->inherit );
@@ -1023,12 +1125,12 @@
     dump_unicode_string( req->name );
 }
 
-static void dump_open_timer_reply( struct open_timer_request *req )
+static void dump_open_timer_reply( const struct open_timer_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
-static void dump_set_timer_request( struct set_timer_request *req )
+static void dump_set_timer_request( const struct set_timer_request *req )
 {
     fprintf( stderr, " handle=%d,", req->handle );
     fprintf( stderr, " sec=%d,", req->sec );
@@ -1038,11 +1140,31 @@
     fprintf( stderr, " arg=%p", req->arg );
 }
 
-static void dump_cancel_timer_request( struct cancel_timer_request *req )
+static void dump_cancel_timer_request( const struct cancel_timer_request *req )
 {
     fprintf( stderr, " handle=%d", req->handle );
 }
 
+static void dump_get_thread_context_request( const struct get_thread_context_request *req )
+{
+    fprintf( stderr, " handle=%d,", req->handle );
+    fprintf( stderr, " flags=%08x", req->flags );
+}
+
+static void dump_get_thread_context_reply( const struct get_thread_context_request *req )
+{
+    fprintf( stderr, " context=" );
+    dump_context( &req->context );
+}
+
+static void dump_set_thread_context_request( const struct set_thread_context_request *req )
+{
+    fprintf( stderr, " handle=%d,", req->handle );
+    fprintf( stderr, " flags=%08x,", req->flags );
+    fprintf( stderr, " context=" );
+    dump_context( &req->context );
+}
+
 static const dump_func req_dumpers[REQ_NB_REQUESTS] = {
     (dump_func)dump_new_process_request,
     (dump_func)dump_new_thread_request,
@@ -1134,6 +1256,8 @@
     (dump_func)dump_open_timer_request,
     (dump_func)dump_set_timer_request,
     (dump_func)dump_cancel_timer_request,
+    (dump_func)dump_get_thread_context_request,
+    (dump_func)dump_set_thread_context_request,
 };
 
 static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
@@ -1227,6 +1351,8 @@
     (dump_func)dump_open_timer_reply,
     (dump_func)0,
     (dump_func)0,
+    (dump_func)dump_get_thread_context_reply,
+    (dump_func)0,
 };
 
 static const char * const req_names[REQ_NB_REQUESTS] = {
@@ -1320,6 +1446,8 @@
     "open_timer",
     "set_timer",
     "cancel_timer",
+    "get_thread_context",
+    "set_thread_context",
 };
 
 /* ### make_requests end ### */