diff --git a/server/trace.c b/server/trace.c
index 0850fd5..1dc815c 100644
--- a/server/trace.c
+++ b/server/trace.c
@@ -6,64 +6,81 @@
 #include "server.h"
 #include "server/thread.h"
 
-static void dump_new_thread_request( struct new_thread_request *req )
+static int dump_new_thread_request( struct new_thread_request *req, int len )
 {
     printf( " pid=%p", req->pid );
+    return (int)sizeof(*req);
 }
 
-static void dump_new_thread_reply( struct new_thread_reply *req )
+static int dump_new_thread_reply( struct new_thread_reply *req, int len )
 {
     printf( " tid=%p,", req->tid );
     printf( " thandle=%d,", req->thandle );
     printf( " pid=%p,", req->pid );
     printf( " phandle=%d", req->phandle );
+    return (int)sizeof(*req);
 }
 
-static void dump_init_thread_request( struct init_thread_request *req )
+static int dump_set_debug_request( struct set_debug_request *req, int len )
 {
-    printf( " unix_pid=%d", req->unix_pid );
+    printf( " level=%d", req->level );
+    return (int)sizeof(*req);
 }
 
-static void dump_terminate_process_request( struct terminate_process_request *req )
+static int dump_init_thread_request( struct init_thread_request *req, int len )
+{
+    printf( " unix_pid=%d,", req->unix_pid );
+    printf( " cmd_line=\"%.*s\"", len - (int)sizeof(*req), (char *)(req+1) );
+    return len;
+}
+
+static int dump_terminate_process_request( struct terminate_process_request *req, int len )
 {
     printf( " handle=%d,", req->handle );
     printf( " exit_code=%d", req->exit_code );
+    return (int)sizeof(*req);
 }
 
-static void dump_terminate_thread_request( struct terminate_thread_request *req )
+static int dump_terminate_thread_request( struct terminate_thread_request *req, int len )
 {
     printf( " handle=%d,", req->handle );
     printf( " exit_code=%d", req->exit_code );
+    return (int)sizeof(*req);
 }
 
-static void dump_get_process_info_request( struct get_process_info_request *req )
+static int dump_get_process_info_request( struct get_process_info_request *req, int len )
 {
     printf( " handle=%d", req->handle );
+    return (int)sizeof(*req);
 }
 
-static void dump_get_process_info_reply( struct get_process_info_reply *req )
+static int dump_get_process_info_reply( struct get_process_info_reply *req, int len )
 {
     printf( " pid=%p,", req->pid );
     printf( " exit_code=%d", req->exit_code );
+    return (int)sizeof(*req);
 }
 
-static void dump_get_thread_info_request( struct get_thread_info_request *req )
+static int dump_get_thread_info_request( struct get_thread_info_request *req, int len )
 {
     printf( " handle=%d", req->handle );
+    return (int)sizeof(*req);
 }
 
-static void dump_get_thread_info_reply( struct get_thread_info_reply *req )
+static int dump_get_thread_info_reply( struct get_thread_info_reply *req, int len )
 {
     printf( " pid=%p,", req->pid );
     printf( " exit_code=%d", req->exit_code );
+    return (int)sizeof(*req);
 }
 
-static void dump_close_handle_request( struct close_handle_request *req )
+static int dump_close_handle_request( struct close_handle_request *req, int len )
 {
     printf( " handle=%d", req->handle );
+    return (int)sizeof(*req);
 }
 
-static void dump_dup_handle_request( struct dup_handle_request *req )
+static int dump_dup_handle_request( struct dup_handle_request *req, int len )
 {
     printf( " src_process=%d,", req->src_process );
     printf( " src_handle=%d,", req->src_handle );
@@ -72,171 +89,222 @@
     printf( " access=%08x,", req->access );
     printf( " inherit=%d,", req->inherit );
     printf( " options=%d", req->options );
+    return (int)sizeof(*req);
 }
 
-static void dump_dup_handle_reply( struct dup_handle_reply *req )
+static int dump_dup_handle_reply( struct dup_handle_reply *req, int len )
 {
     printf( " handle=%d", req->handle );
+    return (int)sizeof(*req);
 }
 
-static void dump_open_process_request( struct open_process_request *req )
+static int dump_open_process_request( struct open_process_request *req, int len )
 {
     printf( " pid=%p,", req->pid );
     printf( " access=%08x,", req->access );
     printf( " inherit=%d", req->inherit );
+    return (int)sizeof(*req);
 }
 
-static void dump_open_process_reply( struct open_process_reply *req )
+static int dump_open_process_reply( struct open_process_reply *req, int len )
 {
     printf( " handle=%d", req->handle );
+    return (int)sizeof(*req);
 }
 
-static void dump_select_request( struct select_request *req )
+static int dump_select_request( struct select_request *req, int len )
 {
     printf( " count=%d,", req->count );
     printf( " flags=%d,", req->flags );
     printf( " timeout=%d", req->timeout );
+    return (int)sizeof(*req);
 }
 
-static void dump_select_reply( struct select_reply *req )
+static int dump_select_reply( struct select_reply *req, int len )
 {
     printf( " signaled=%d", req->signaled );
+    return (int)sizeof(*req);
 }
 
-static void dump_create_event_request( struct create_event_request *req )
+static int dump_create_event_request( struct create_event_request *req, int len )
 {
     printf( " manual_reset=%d,", req->manual_reset );
     printf( " initial_state=%d,", req->initial_state );
-    printf( " inherit=%d", req->inherit );
+    printf( " inherit=%d,", req->inherit );
+    printf( " name=\"%.*s\"", len - (int)sizeof(*req), (char *)(req+1) );
+    return len;
 }
 
-static void dump_create_event_reply( struct create_event_reply *req )
+static int dump_create_event_reply( struct create_event_reply *req, int len )
 {
     printf( " handle=%d", req->handle );
+    return (int)sizeof(*req);
 }
 
-static void dump_event_op_request( struct event_op_request *req )
+static int dump_event_op_request( struct event_op_request *req, int len )
 {
     printf( " handle=%d,", req->handle );
     printf( " op=%d", req->op );
+    return (int)sizeof(*req);
 }
 
-static void dump_create_mutex_request( struct create_mutex_request *req )
+static int dump_create_mutex_request( struct create_mutex_request *req, int len )
 {
     printf( " owned=%d,", req->owned );
-    printf( " inherit=%d", req->inherit );
+    printf( " inherit=%d,", req->inherit );
+    printf( " name=\"%.*s\"", len - (int)sizeof(*req), (char *)(req+1) );
+    return len;
 }
 
-static void dump_create_mutex_reply( struct create_mutex_reply *req )
+static int dump_create_mutex_reply( struct create_mutex_reply *req, int len )
 {
     printf( " handle=%d", req->handle );
+    return (int)sizeof(*req);
 }
 
-static void dump_release_mutex_request( struct release_mutex_request *req )
+static int dump_release_mutex_request( struct release_mutex_request *req, int len )
 {
     printf( " handle=%d", req->handle );
+    return (int)sizeof(*req);
 }
 
-static void dump_create_semaphore_request( struct create_semaphore_request *req )
+static int dump_create_semaphore_request( struct create_semaphore_request *req, int len )
 {
     printf( " initial=%08x,", req->initial );
     printf( " max=%08x,", req->max );
     printf( " inherit=%d", req->inherit );
+    return (int)sizeof(*req);
 }
 
-static void dump_create_semaphore_reply( struct create_semaphore_reply *req )
+static int dump_create_semaphore_reply( struct create_semaphore_reply *req, int len )
 {
     printf( " handle=%d", req->handle );
+    return (int)sizeof(*req);
 }
 
-static void dump_release_semaphore_request( struct release_semaphore_request *req )
+static int dump_release_semaphore_request( struct release_semaphore_request *req, int len )
 {
     printf( " handle=%d,", req->handle );
     printf( " count=%08x", req->count );
+    return (int)sizeof(*req);
 }
 
-static void dump_release_semaphore_reply( struct release_semaphore_reply *req )
+static int dump_release_semaphore_reply( struct release_semaphore_reply *req, int len )
 {
     printf( " prev_count=%08x", req->prev_count );
+    return (int)sizeof(*req);
 }
 
-static void dump_open_named_obj_request( struct open_named_obj_request *req )
+static int dump_open_named_obj_request( struct open_named_obj_request *req, int len )
 {
     printf( " type=%d,", req->type );
     printf( " access=%08x,", req->access );
     printf( " inherit=%d", req->inherit );
+    return (int)sizeof(*req);
 }
 
-static void dump_open_named_obj_reply( struct open_named_obj_reply *req )
+static int dump_open_named_obj_reply( struct open_named_obj_reply *req, int len )
 {
     printf( " handle=%d", req->handle );
+    return (int)sizeof(*req);
+}
+
+static int dump_create_file_request( struct create_file_request *req, int len )
+{
+    printf( " access=%08x,", req->access );
+    printf( " inherit=%d", req->inherit );
+    return (int)sizeof(*req);
+}
+
+static int dump_create_file_reply( struct create_file_reply *req, int len )
+{
+    printf( " handle=%d", req->handle );
+    return (int)sizeof(*req);
+}
+
+static int dump_get_unix_handle_request( struct get_unix_handle_request *req, int len )
+{
+    printf( " handle=%d,", req->handle );
+    printf( " access=%08x", req->access );
+    return (int)sizeof(*req);
+}
+
+static int dump_get_file_info_request( struct get_file_info_request *req, int len )
+{
+    printf( " handle=%d", req->handle );
+    return (int)sizeof(*req);
+}
+
+static int dump_get_file_info_reply( struct get_file_info_reply *req, int len )
+{
+    printf( " attr=%d,", req->attr );
+    printf( " access_time=%ld,", req->access_time );
+    printf( " write_time=%ld,", req->write_time );
+    printf( " size_high=%d,", req->size_high );
+    printf( " size_low=%d,", req->size_low );
+    printf( " links=%d,", req->links );
+    printf( " index_high=%d,", req->index_high );
+    printf( " index_low=%d,", req->index_low );
+    printf( " serial=%08x", req->serial );
+    return (int)sizeof(*req);
 }
 
 struct dumper
 {
-    void (*dump_req)();
-    void (*dump_reply)();
-    unsigned int size;
+    int (*dump_req)( void *data, int len );
+    void (*dump_reply)( void *data );
 };
 
 static const struct dumper dumpers[REQ_NB_REQUESTS] =
 {
-    { (void(*)())dump_new_thread_request,
-      (void(*)())dump_new_thread_reply,
-      sizeof(struct new_thread_request) },
-    { (void(*)())dump_init_thread_request,
-      (void(*)())0,
-      sizeof(struct init_thread_request) },
-    { (void(*)())dump_terminate_process_request,
-      (void(*)())0,
-      sizeof(struct terminate_process_request) },
-    { (void(*)())dump_terminate_thread_request,
-      (void(*)())0,
-      sizeof(struct terminate_thread_request) },
-    { (void(*)())dump_get_process_info_request,
-      (void(*)())dump_get_process_info_reply,
-      sizeof(struct get_process_info_request) },
-    { (void(*)())dump_get_thread_info_request,
-      (void(*)())dump_get_thread_info_reply,
-      sizeof(struct get_thread_info_request) },
-    { (void(*)())dump_close_handle_request,
-      (void(*)())0,
-      sizeof(struct close_handle_request) },
-    { (void(*)())dump_dup_handle_request,
-      (void(*)())dump_dup_handle_reply,
-      sizeof(struct dup_handle_request) },
-    { (void(*)())dump_open_process_request,
-      (void(*)())dump_open_process_reply,
-      sizeof(struct open_process_request) },
-    { (void(*)())dump_select_request,
-      (void(*)())dump_select_reply,
-      sizeof(struct select_request) },
-    { (void(*)())dump_create_event_request,
-      (void(*)())dump_create_event_reply,
-      sizeof(struct create_event_request) },
-    { (void(*)())dump_event_op_request,
-      (void(*)())0,
-      sizeof(struct event_op_request) },
-    { (void(*)())dump_create_mutex_request,
-      (void(*)())dump_create_mutex_reply,
-      sizeof(struct create_mutex_request) },
-    { (void(*)())dump_release_mutex_request,
-      (void(*)())0,
-      sizeof(struct release_mutex_request) },
-    { (void(*)())dump_create_semaphore_request,
-      (void(*)())dump_create_semaphore_reply,
-      sizeof(struct create_semaphore_request) },
-    { (void(*)())dump_release_semaphore_request,
-      (void(*)())dump_release_semaphore_reply,
-      sizeof(struct release_semaphore_request) },
-    { (void(*)())dump_open_named_obj_request,
-      (void(*)())dump_open_named_obj_reply,
-      sizeof(struct open_named_obj_request) },
+    { (int(*)(void *,int))dump_new_thread_request,
+      (void(*)())dump_new_thread_reply },
+    { (int(*)(void *,int))dump_set_debug_request,
+      (void(*)())0 },
+    { (int(*)(void *,int))dump_init_thread_request,
+      (void(*)())0 },
+    { (int(*)(void *,int))dump_terminate_process_request,
+      (void(*)())0 },
+    { (int(*)(void *,int))dump_terminate_thread_request,
+      (void(*)())0 },
+    { (int(*)(void *,int))dump_get_process_info_request,
+      (void(*)())dump_get_process_info_reply },
+    { (int(*)(void *,int))dump_get_thread_info_request,
+      (void(*)())dump_get_thread_info_reply },
+    { (int(*)(void *,int))dump_close_handle_request,
+      (void(*)())0 },
+    { (int(*)(void *,int))dump_dup_handle_request,
+      (void(*)())dump_dup_handle_reply },
+    { (int(*)(void *,int))dump_open_process_request,
+      (void(*)())dump_open_process_reply },
+    { (int(*)(void *,int))dump_select_request,
+      (void(*)())dump_select_reply },
+    { (int(*)(void *,int))dump_create_event_request,
+      (void(*)())dump_create_event_reply },
+    { (int(*)(void *,int))dump_event_op_request,
+      (void(*)())0 },
+    { (int(*)(void *,int))dump_create_mutex_request,
+      (void(*)())dump_create_mutex_reply },
+    { (int(*)(void *,int))dump_release_mutex_request,
+      (void(*)())0 },
+    { (int(*)(void *,int))dump_create_semaphore_request,
+      (void(*)())dump_create_semaphore_reply },
+    { (int(*)(void *,int))dump_release_semaphore_request,
+      (void(*)())dump_release_semaphore_reply },
+    { (int(*)(void *,int))dump_open_named_obj_request,
+      (void(*)())dump_open_named_obj_reply },
+    { (int(*)(void *,int))dump_create_file_request,
+      (void(*)())dump_create_file_reply },
+    { (int(*)(void *,int))dump_get_unix_handle_request,
+      (void(*)())0 },
+    { (int(*)(void *,int))dump_get_file_info_request,
+      (void(*)())dump_get_file_info_reply },
 };
 
 static const char * const req_names[REQ_NB_REQUESTS] =
 {
     "new_thread",
+    "set_debug",
     "init_thread",
     "terminate_process",
     "terminate_thread",
@@ -253,17 +321,20 @@
     "create_semaphore",
     "release_semaphore",
     "open_named_obj",
+    "create_file",
+    "get_unix_handle",
+    "get_file_info",
 };
 
 void trace_request( enum request req, void *data, int len, int fd )
 {
+    int size;
     current->last_req = req;
     printf( "%08x: %s(", (unsigned int)current, req_names[req] );
-    dumpers[req].dump_req( data );
-    if (len > dumpers[req].size)
+    size = dumpers[req].dump_req( data, len );
+    if ((len -= size) > 0)
     {
-        unsigned char *ptr = (unsigned char *)data + dumpers[req].size;
-	len -= dumpers[req].size;
+        unsigned char *ptr = (unsigned char *)data + size;
         while (len--) printf( ", %02x", *ptr++ );
     }
     if (fd != -1) printf( " ) fd=%d\n", fd );