diff --git a/include/process.h b/include/process.h
index 249d16f..045bd78 100644
--- a/include/process.h
+++ b/include/process.h
@@ -170,8 +170,6 @@
 
 /* scheduler/debugger.c */
 extern DWORD DEBUG_SendExceptionEvent( EXCEPTION_RECORD *rec, BOOL first_chance, CONTEXT *ctx );
-extern DWORD DEBUG_SendCreateProcessEvent( HFILE file, HMODULE module, void *entry );
-extern DWORD DEBUG_SendCreateThreadEvent( void *entry );
 extern DWORD DEBUG_SendLoadDLLEvent( HFILE file, HMODULE module, LPSTR *name );
 extern DWORD DEBUG_SendUnloadDLLEvent( HMODULE module );
 
diff --git a/include/server.h b/include/server.h
index 6eb99c3..2c5f91c 100644
--- a/include/server.h
+++ b/include/server.h
@@ -165,7 +165,8 @@
 /* Signal the end of the process initialization */
 struct init_process_done_request
 {
-    IN  int          dummy;
+    IN  void*        module;       /* main module base address */
+    IN  void*        entry;        /* process entry point */
 };
 
 
@@ -174,9 +175,7 @@
 {
     IN  int          unix_pid;     /* Unix pid of new thread */
     IN  void*        teb;          /* TEB of new thread (in thread address space) */
-    OUT void*        pid;          /* process id of the new thread's process */
-    OUT void*        tid;          /* thread id of the new thread */
-    OUT int          boot;         /* is this the boot thread? */
+    IN  void*        entry;        /* thread entry point (in thread address space) */
 };
 
 
@@ -185,7 +184,9 @@
 /* created thread gets (without having to request it) */
 struct get_thread_buffer_request
 {
-    IN  int          dummy;
+    OUT void*        pid;          /* process id of the new thread's process */
+    OUT void*        tid;          /* thread id of the new thread */
+    OUT int          boot;         /* is this the boot thread? */
 };
 
 
diff --git a/scheduler/client.c b/scheduler/client.c
index bd097f8..27d4d1b 100644
--- a/scheduler/client.c
+++ b/scheduler/client.c
@@ -453,6 +453,7 @@
  */
 int CLIENT_InitThread(void)
 {
+    struct get_thread_buffer_request *first_req;
     struct init_thread_request *req;
     TEB *teb = NtCurrentTeb();
     int fd;
@@ -463,16 +464,17 @@
     teb->buffer = mmap( 0, teb->buffer_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0 );
     close( fd );
     if (teb->buffer == (void*)-1) server_perror( "mmap" );
+    first_req = teb->buffer;
+    teb->process->server_pid = first_req->pid;
+    teb->tid = first_req->tid;
+    if (first_req->boot) boot_thread_id = teb->tid;
+    else if (boot_thread_id == teb->tid) boot_thread_id = 0;
 
-    req = get_req_buffer();
+    req = teb->buffer;
     req->unix_pid = getpid();
     req->teb      = teb;
-    if (server_call( REQ_INIT_THREAD )) return -1;
-    teb->process->server_pid = req->pid;
-    teb->tid = req->tid;
-    if (req->boot) boot_thread_id = req->tid;
-    else if (boot_thread_id == req->tid) boot_thread_id = 0;
-    return 0;
+    req->entry    = teb->entry_point;
+    return server_call_noerr( REQ_INIT_THREAD );
 }
 
 /***********************************************************************
diff --git a/scheduler/debugger.c b/scheduler/debugger.c
index 8a09485..f8357d1 100644
--- a/scheduler/debugger.c
+++ b/scheduler/debugger.c
@@ -6,8 +6,8 @@
 
 #include <string.h>
 
+#include "winerror.h"
 #include "process.h"
-#include "thread.h"
 #include "server.h"
 #include "debugtools.h"
 
@@ -22,7 +22,6 @@
 DWORD DEBUG_SendExceptionEvent( EXCEPTION_RECORD *rec, BOOL first_chance, CONTEXT *context )
 {
     int i;
-    DWORD ret = 0;
     struct send_debug_event_request *req = get_req_buffer();
 
     req->event.code = EXCEPTION_DEBUG_EVENT;
@@ -35,58 +34,9 @@
     req->event.info.exception.context      = *context;
     for (i = 0; i < req->event.info.exception.nb_params; i++)
         req->event.info.exception.params[i] = rec->ExceptionInformation[i];
-    if (!server_call( REQ_SEND_DEBUG_EVENT ))
-    {
-        ret = req->status;
+    if (!server_call_noerr( REQ_SEND_DEBUG_EVENT ))
         *context = req->event.info.exception.context;
-    }
-    return ret;
-}
-
-
-/**********************************************************************
- *           DEBUG_SendCreateProcessEvent
- *
- * Send an CREATE_PROCESS_DEBUG_EVENT event to the current process debugger.
- * Must be called from the context of the new process.
- */
-DWORD DEBUG_SendCreateProcessEvent( HFILE file, HMODULE module, void *entry )
-{
-    DWORD ret = 0;
-    struct send_debug_event_request *req = get_req_buffer();
-
-    req->event.code = CREATE_PROCESS_DEBUG_EVENT;
-    req->event.info.create_process.file       = file;
-    req->event.info.create_process.process    = 0; /* will be filled by server */
-    req->event.info.create_process.thread     = 0; /* will be filled by server */
-    req->event.info.create_process.base       = (void *)module;
-    req->event.info.create_process.dbg_offset = 0; /* FIXME */
-    req->event.info.create_process.dbg_size   = 0; /* FIXME */
-    req->event.info.create_process.teb        = NtCurrentTeb();
-    req->event.info.create_process.start      = entry;
-    req->event.info.create_process.name       = 0; /* FIXME */
-    req->event.info.create_process.unicode    = 0; /* FIXME */
-    if (!server_call( REQ_SEND_DEBUG_EVENT )) ret = req->status;
-    return ret;
-}
-
-/**********************************************************************
- *           DEBUG_SendCreateThreadEvent
- *
- * Send an CREATE_THREAD_DEBUG_EVENT event to the current process debugger.
- * Must be called from the context of the new thread.
- */
-DWORD DEBUG_SendCreateThreadEvent( void *entry )
-{
-    DWORD ret = 0;
-    struct send_debug_event_request *req = get_req_buffer();
-
-    req->event.code = CREATE_THREAD_DEBUG_EVENT;
-    req->event.info.create_thread.handle = 0; /* will be filled by server */
-    req->event.info.create_thread.teb    = NtCurrentTeb();
-    req->event.info.create_thread.start  = entry;
-    if (!server_call( REQ_SEND_DEBUG_EVENT )) ret = req->status;
-    return ret;
+    return req->status;
 }
 
 
@@ -97,7 +47,6 @@
  */
 DWORD DEBUG_SendLoadDLLEvent( HFILE file, HMODULE module, LPSTR *name )
 {
-    DWORD ret = 0;
     struct send_debug_event_request *req = get_req_buffer();
 
     req->event.code = LOAD_DLL_DEBUG_EVENT;
@@ -107,8 +56,8 @@
     req->event.info.load_dll.dbg_size   = 0;  /* FIXME */
     req->event.info.load_dll.name       = name;
     req->event.info.load_dll.unicode    = 0;
-    if (!server_call( REQ_SEND_DEBUG_EVENT )) ret = req->status;
-    return ret;
+    server_call_noerr( REQ_SEND_DEBUG_EVENT );
+    return req->status;
 }
 
 
@@ -119,13 +68,12 @@
  */
 DWORD DEBUG_SendUnloadDLLEvent( HMODULE module )
 {
-    DWORD ret = 0;
     struct send_debug_event_request *req = get_req_buffer();
 
     req->event.code = UNLOAD_DLL_DEBUG_EVENT;
     req->event.info.unload_dll.base = (void *)module;
-    if (!server_call( REQ_SEND_DEBUG_EVENT )) ret = req->status;
-    return ret;
+    server_call_noerr( REQ_SEND_DEBUG_EVENT );
+    return req->status;
 }
 
 
@@ -155,6 +103,9 @@
     event->dwThreadId       = (DWORD)req->tid;
     switch(req->event.code)
     {
+    case 0:  /* timeout */
+        SetLastError( ERROR_SEM_TIMEOUT );
+        return FALSE;
     case EXCEPTION_DEBUG_EVENT:
         event->u.Exception.ExceptionRecord.ExceptionCode    = req->event.info.exception.code;
         event->u.Exception.ExceptionRecord.ExceptionFlags   = req->event.info.exception.flags;
diff --git a/scheduler/process.c b/scheduler/process.c
index 56167a6..a1b68f7 100644
--- a/scheduler/process.c
+++ b/scheduler/process.c
@@ -26,7 +26,6 @@
 #include "server.h"
 #include "options.h"
 #include "callback.h"
-#include "debugger.h"
 #include "debugtools.h"
 
 DEFAULT_DEBUG_CHANNEL(process)
@@ -371,6 +370,7 @@
  */
 void PROCESS_Start(void)
 {
+    struct init_process_done_request *req = get_req_buffer();
     UINT cmdShow = SW_SHOWNORMAL;
     LPTHREAD_START_ROUTINE entry = NULL;
     PDB *pdb = PROCESS_Current();
@@ -452,16 +452,15 @@
     PROCESS_CallUserSignalProc( USIG_PROCESS_LOADED, 0, 0 );
 
     /* Signal the parent process to continue */
+    req->module = (void *)pModule->module32;
+    req->entry  = entry;
     server_call( REQ_INIT_PROCESS_DONE );
 
     /* Send all required start-up debugger events */
     if ( type == PROC_WIN32 && (pdb->flags & PDB32_DEBUGGED) )
     {
         EnterCriticalSection( &pdb->crit_section );
-
-        DEBUG_SendCreateProcessEvent( -1 /*FIXME*/, pModule->module32, entry );
         MODULE_SendLoadDLLEvents();
-
         LeaveCriticalSection( &pdb->crit_section );
     }
 
@@ -479,10 +478,6 @@
         LeaveCriticalSection( &pdb->crit_section );
     }
 
-    /* If requested, add entry point breakpoint */
-    if ( Options.debug || (pdb->flags & PDB32_DEBUGGED) )
-        DEBUG_AddTaskEntryBreakpoint( pdb->task );
-
     /* Call UserSignalProc ( USIG_PROCESS_RUNNING ... ) only for non-GUI win32 apps */
     if ( type != PROC_WIN16 && (pdb->flags & PDB32_CONSOLE_PROC))
         PROCESS_CallUserSignalProc( USIG_PROCESS_RUNNING, 0, 0 );
diff --git a/scheduler/thread.c b/scheduler/thread.c
index 17310be..9082cb8 100644
--- a/scheduler/thread.c
+++ b/scheduler/thread.c
@@ -276,9 +276,6 @@
     PROCESS_CallUserSignalProc( USIG_THREAD_INIT, (DWORD)NtCurrentTeb()->tid, 0 );
     PE_InitTls();
     MODULE_DllThreadAttach( NULL );
-
-    if (NtCurrentTeb()->process->flags & PDB32_DEBUGGED) DEBUG_SendCreateThreadEvent( func );
-
     ExitThread( func( NtCurrentTeb()->entry_arg ) );
 }
 
diff --git a/server/debugger.c b/server/debugger.c
index 01ce211..b62d0d3 100644
--- a/server/debugger.c
+++ b/server/debugger.c
@@ -97,30 +97,43 @@
                /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
                                                               THREAD_ALL_ACCESS, FALSE )) == -1)
             return 0;
+        event->data.info.create_thread.teb   = thread->teb;
+        event->data.info.create_thread.start = thread->entry;
         break;
     case CREATE_PROCESS_DEBUG_EVENT:
-        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.info.create_process.file = handle;
-        }
-        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 );
+        if ((handle = alloc_handle( debugger->process, thread->process,
+                                    /* documented: PROCESS_VM_READ | PROCESS_VM_WRITE */
+                                    PROCESS_ALL_ACCESS, FALSE )) == -1)
             return 0;
-        }
-        if ((event->data.info.create_process.thread = alloc_handle( debugger->process, thread,
+        event->data.info.create_process.process = handle;
+
+        if ((handle = alloc_handle( debugger->process, thread,
                /* documented: THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME */
-                                                               THREAD_ALL_ACCESS, FALSE )) == -1)
+                                    THREAD_ALL_ACCESS, FALSE )) == -1)
         {
-            if (handle != -1) close_handle( debugger->process, handle );
             close_handle( debugger->process, event->data.info.create_process.process );
             return 0;
         }
+        event->data.info.create_process.thread = handle;
+
+        handle = -1;
+        if (thread->process->exe_file &&
+            ((handle = alloc_handle( debugger->process, thread->process->exe_file,
+                        /* the doc says write access too, but this doesn't seem a good idea */
+                                     GENERIC_READ, FALSE )) == -1))
+        {
+            close_handle( debugger->process, event->data.info.create_process.process );
+            close_handle( debugger->process, event->data.info.create_process.thread );
+            return 0;
+        }
+        event->data.info.create_process.file       = handle;
+        event->data.info.create_process.teb        = thread->teb;
+        event->data.info.create_process.base       = thread->process->module;
+        event->data.info.create_process.start      = thread->entry;
+        event->data.info.create_process.dbg_offset = 0;
+        event->data.info.create_process.dbg_size   = 0;
+        event->data.info.create_process.name       = 0;
+        event->data.info.create_process.unicode    = 0;
         break;
     case LOAD_DLL_DEBUG_EVENT:
         if ((handle = event->data.info.load_dll.handle) != -1)
@@ -131,6 +144,15 @@
             event->data.info.load_dll.handle = handle;
         }
         break;
+    case EXIT_PROCESS_DEBUG_EVENT:
+    case EXIT_THREAD_DEBUG_EVENT:
+        event->data.info.exit.exit_code = thread->exit_code;
+        break;
+    case EXCEPTION_DEBUG_EVENT:
+    case UNLOAD_DLL_DEBUG_EVENT:
+    case OUTPUT_DEBUG_STRING_EVENT:
+    case RIP_EVENT:
+        break;
     }
     return 1;
 }
@@ -189,7 +211,6 @@
         req->event.code = 0;
         req->pid  = 0;
         req->tid  = 0;
-        thread->error = signaled;
     }
 }
 
@@ -330,9 +351,10 @@
 }
 
 /* queue a debug event for a debugger */
-static struct debug_event *queue_debug_event( struct thread *debugger, struct thread *thread,
+static struct debug_event *queue_debug_event( struct thread *thread, int code,
                                               debug_event_t *data )
 {
+    struct thread *debugger = thread->process->debugger;
     struct debug_ctx *debug_ctx = debugger->debug_ctx;
     struct debug_event *event;
 
@@ -347,7 +369,8 @@
     event->state    = EVENT_QUEUED;
     event->sender   = (struct thread *)grab_object( thread );
     event->debugger = (struct thread *)grab_object( debugger );
-    memcpy( &event->data, data, sizeof(event->data) );
+    if (data) memcpy( &event->data, data, sizeof(event->data) );
+    event->data.code = code;
 
     if (!fill_debug_event( debugger, thread, event ))
     {
@@ -361,6 +384,16 @@
     return event;
 }
 
+/* generate a debug event from inside the server and queue it */
+void generate_debug_event( struct thread *thread, int code )
+{
+    if (thread->process->debugger)
+    {
+        struct debug_event *event = queue_debug_event( thread, code, NULL );
+        if (event) release_object( event );
+    }
+}
+
 /* return a pointer to the context in case the thread is inside an exception event */
 CONTEXT *get_debug_context( struct thread *thread )
 {
@@ -409,29 +442,14 @@
 }
 
 /* a thread is exiting */
-void debug_exit_thread( struct thread *thread, int exit_code )
+void debug_exit_thread( struct thread *thread )
 {
-    struct thread *debugger = thread->process->debugger;
-    struct debug_ctx *debug_ctx = thread->debug_ctx;
-
-    if (debugger)  /* being debugged -> send an event to the debugger */
-    {
-        struct debug_event *event;
-        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 );
-    }
-
-    if (debug_ctx)  /* this thread is a debugger */
+    if (thread->debug_ctx)  /* this thread is a debugger */
     {
         /* kill all debugged processes */
-        kill_debugged_processes( thread, exit_code );
+        kill_debugged_processes( thread, thread->exit_code );
+        release_object( thread->debug_ctx );
         thread->debug_ctx = NULL;
-        release_object( debug_ctx );
     }
 }
 
@@ -466,27 +484,30 @@
 DECL_HANDLER(debug_process)
 {
     struct process *process = get_process_from_id( req->pid );
-    if (process)
+    if (!process) return;
+    if (debugger_attach( process, current ))
     {
-        debugger_attach( process, current );
-        /* FIXME: should notify the debugged process somehow */
-        release_object( process );
+        struct thread *thread = process->thread_list;
+        generate_debug_event( thread, CREATE_PROCESS_DEBUG_EVENT );
+        while ((thread = thread->next)) generate_debug_event( thread, CREATE_THREAD_DEBUG_EVENT );
+        /* FIXME: load dll + breakpoint exception events */
     }
+    release_object( process );
 }
 
 /* Send a debug event */
 DECL_HANDLER(send_debug_event)
 {
-    struct thread *debugger = current->process->debugger;
     struct debug_event *event;
+    int code = req->event.code;
 
-    if ((req->event.code <= 0) || (req->event.code > RIP_EVENT))
+    if ((code <= 0) || (code > RIP_EVENT))
     {
-        fatal_protocol_error( current, "send_debug_event: bad code %d\n", req->event.code );
+        fatal_protocol_error( current, "send_debug_event: bad code %d\n", code );
         return;
     }
     req->status = 0;
-    if (debugger && ((event = queue_debug_event( debugger, current, &req->event ))))
+    if (current->process->debugger && ((event = queue_debug_event( current, code, &req->event ))))
     {
         /* wait for continue_debug_event */
         struct object *obj = &event->obj;
diff --git a/server/object.h b/server/object.h
index 0a7ad5d..3f87b85 100644
--- a/server/object.h
+++ b/server/object.h
@@ -154,7 +154,8 @@
 /* debugger functions */
 
 extern int debugger_attach( struct process *process, struct thread *debugger );
-extern void debug_exit_thread( struct thread *thread, int exit_code );
+extern void generate_debug_event( struct thread *thread, int code );
+extern void debug_exit_thread( struct thread *thread );
 extern CONTEXT *get_debug_context( struct thread *thread );
 
 /* mapping functions */
diff --git a/server/process.c b/server/process.c
index 0dd779d..9d01b5f 100644
--- a/server/process.c
+++ b/server/process.c
@@ -584,6 +584,9 @@
         fatal_protocol_error( current, "init_process_done: no event\n" );
         return;
     }
+    current->entry  = req->entry;
+    process->module = req->module;
+    generate_debug_event( current, CREATE_PROCESS_DEBUG_EVENT );
     set_event( process->init_event );
     release_object( process->init_event );
     process->init_event = NULL;
diff --git a/server/process.h b/server/process.h
index 873aad7..e8e7cc6 100644
--- a/server/process.h
+++ b/server/process.h
@@ -37,6 +37,7 @@
     struct event        *init_event;      /* event for init done */
     void                *ldt_copy;        /* pointer to LDT copy in client addr space */
     void                *ldt_flags;       /* pointer to LDT flags in client addr space */
+    void                *module;          /* main module base address */
     struct new_process_request *info;     /* startup info (freed after startup) */
 };
 
@@ -66,4 +67,6 @@
 extern void kill_debugged_processes( struct thread *debugger, int exit_code );
 extern struct process_snapshot *process_snap( int *count );
 
+static inline void *get_process_id( struct process *process ) { return process; }
+
 #endif  /* __WINE_SERVER_PROCESS_H */
diff --git a/server/thread.c b/server/thread.c
index b042158..14d7ea6 100644
--- a/server/thread.c
+++ b/server/thread.c
@@ -92,25 +92,32 @@
 /* allocate the buffer for the communication with the client */
 static int alloc_client_buffer( struct thread *thread )
 {
+    struct get_thread_buffer_request *req;
     int fd;
 
     if ((fd = create_anonymous_file()) == -1) return -1;
     if (ftruncate( fd, MAX_REQUEST_LENGTH ) == -1) goto error;
     if ((thread->buffer = mmap( 0, MAX_REQUEST_LENGTH, PROT_READ | PROT_WRITE,
                                 MAP_SHARED, fd, 0 )) == (void*)-1) goto error;
-    return fd;
+    /* build the first request into the buffer and send it */
+    req = thread->buffer;
+    req->pid  = get_process_id( thread->process );
+    req->tid  = get_thread_id( thread );
+    req->boot = (thread == booting_thread);
+    set_reply_fd( thread, fd );
+    send_reply( thread );
+    return 1;
 
  error:
     file_set_error();
     if (fd != -1) close( fd );
-    return -1;
+    return 0;
 }
 
 /* create a new thread */
 struct thread *create_thread( int fd, struct process *process, int suspend )
 {
     struct thread *thread;
-    int buf_fd;
 
     int flags = fcntl( fd, F_GETFL, 0 );
     fcntl( fd, F_SETFL, flags | O_NONBLOCK );
@@ -150,11 +157,8 @@
     first_thread = thread;
     add_process_thread( process, thread );
 
-    if ((buf_fd = alloc_client_buffer( thread )) == -1) goto error;
-
     set_select_events( &thread->obj, POLLIN );  /* start listening to events */
-    set_reply_fd( thread, buf_fd );  /* send the fd to the client */
-    send_reply( thread );
+    if (!alloc_client_buffer( thread )) goto error;
     return thread;
 
  error:
@@ -560,7 +564,9 @@
     if (current == thread) current = NULL;
     if (debug_level) trace_kill( thread );
     if (thread->wait) end_wait( thread );
-    debug_exit_thread( thread, exit_code );
+    generate_debug_event( thread, (thread->process->running_threads == 1) ?
+                          EXIT_PROCESS_DEBUG_EVENT : EXIT_THREAD_DEBUG_EVENT );
+    debug_exit_thread( thread );
     abandon_mutexes( thread );
     remove_process_thread( thread->process, thread );
     wake_up( &thread->obj, 0 );
@@ -623,10 +629,10 @@
     }
     current->unix_pid = req->unix_pid;
     current->teb      = req->teb;
+    current->entry    = req->entry;
     if (current->suspend + current->process->suspend > 0) stop_thread( current );
-    req->pid  = current->process;
-    req->tid  = current;
-    req->boot = (current == booting_thread);
+    if (current->process->running_threads > 1)
+        generate_debug_event( current, CREATE_THREAD_DEBUG_EVENT );
 }
 
 /* terminate a thread */
diff --git a/server/thread.h b/server/thread.h
index 5e46493..9cc088d 100644
--- a/server/thread.h
+++ b/server/thread.h
@@ -48,6 +48,7 @@
     int                 exit_code; /* thread exit code */
     int                 unix_pid;  /* Unix pid of client */
     void               *teb;       /* TEB address (in client address space) */
+    void               *entry;     /* thread entry point (in client address space) */
     int                 priority;  /* priority level */
     int                 affinity;  /* affinity mask */
     int                 suspend;   /* suspend count */
@@ -92,4 +93,6 @@
 static inline void set_error( int err ) { current->error = err; }
 static inline void clear_error(void)    { set_error(0); }
 
+static inline void *get_thread_id( struct thread *thread ) { return thread; }
+
 #endif  /* __WINE_SERVER_THREAD_H */
diff --git a/server/trace.c b/server/trace.c
index c38f7db..79ffa2e 100644
--- a/server/trace.c
+++ b/server/trace.c
@@ -258,25 +258,26 @@
 
 static void dump_init_process_done_request( const struct init_process_done_request *req )
 {
-    fprintf( stderr, " dummy=%d", req->dummy );
+    fprintf( stderr, " module=%p,", req->module );
+    fprintf( stderr, " entry=%p", req->entry );
 }
 
 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( const struct init_thread_request *req )
-{
-    fprintf( stderr, " pid=%p,", req->pid );
-    fprintf( stderr, " tid=%p,", req->tid );
-    fprintf( stderr, " boot=%d", req->boot );
+    fprintf( stderr, " teb=%p,", req->teb );
+    fprintf( stderr, " entry=%p", req->entry );
 }
 
 static void dump_get_thread_buffer_request( const struct get_thread_buffer_request *req )
 {
-    fprintf( stderr, " dummy=%d", req->dummy );
+}
+
+static void dump_get_thread_buffer_reply( const struct get_thread_buffer_request *req )
+{
+    fprintf( stderr, " pid=%p,", req->pid );
+    fprintf( stderr, " tid=%p,", req->tid );
+    fprintf( stderr, " boot=%d", req->boot );
 }
 
 static void dump_terminate_process_request( const struct terminate_process_request *req )
@@ -1329,8 +1330,8 @@
     (dump_func)0,
     (dump_func)dump_init_process_reply,
     (dump_func)0,
-    (dump_func)dump_init_thread_reply,
     (dump_func)0,
+    (dump_func)dump_get_thread_buffer_reply,
     (dump_func)0,
     (dump_func)0,
     (dump_func)dump_get_process_info_reply,