Added separate server pipe to wait on blocking server calls.

dlls/kernel/kernel.spec

@@ -369,8 +369,8 @@ owner	kernel32
 457 pascal CreateW32Event(long long) WIN16_CreateEvent
 458 pascal SetW32Event(long) SetEvent
 459 pascal ResetW32Event(long) ResetEvent
-460 pascal WaitForSingleObject(long long) WIN16_WaitForSingleObject
-461 pascal WaitForMultipleObjects(long ptr long long) WIN16_WaitForMultipleObjects
+460 pascal WaitForSingleObject(long long) WaitForSingleObject16
+461 pascal WaitForMultipleObjects(long ptr long long) WaitForMultipleObjects16
 462 pascal GetCurrentThreadId() GetCurrentThreadId
 463 pascal SetThreadQueue(long word) SetThreadQueue16
 464 pascal GetThreadQueue(long) GetThreadQueue16
@@ -406,7 +406,7 @@ owner	kernel32
 494 stub KERNEL_494
 
 # 495 is present only in Win98
-495 pascal WaitForMultipleObjectsEx(long ptr long long long) WIN16_WaitForMultipleObjectsEx
+495 pascal WaitForMultipleObjectsEx(long ptr long long long) WaitForMultipleObjectsEx16
 
 # 500-544 are WinNT extensions; some are also available in Win95
 

include/server.h

@@ -417,7 +417,6 @@ struct select_request
     IN  int          flags;        /* wait flags (see below) */
     IN  int          sec;          /* absolute timeout */
     IN  int          usec;         /* absolute timeout */
-    OUT int          signaled;     /* signaled handle */
     IN  VARARG(handles,handles);   /* handles to select on */
 };
 #define SELECT_ALL           1
@@ -1593,7 +1592,7 @@ union generic_request
     struct async_result_request async_result;
 };
 
-#define SERVER_PROTOCOL_VERSION 38
+#define SERVER_PROTOCOL_VERSION 39
 
 /* ### make_requests end ### */
 /* Everything above this line is generated automatically by tools/make_requests */

include/thread.h

@@ -96,13 +96,14 @@ typedef struct _TEB
     void        *buffer;         /* --3 204 Buffer shared with server */
     int          request_fd;     /* --3 208 fd for sending server requests */
     int          reply_fd;       /* --3 20c fd for receiving server replies */
-    struct server_buffer_info *buffer_info;   /* --3 210 Buffer information */
-    void        *debug_info;     /* --3 214 Info for debugstr functions */
-    void        *pthread_data;   /* --3 218 Data for pthread emulation */
+    int          wait_fd;        /* --3 210 fd for sleeping server requests */
+    struct server_buffer_info *buffer_info;   /* --3 214 Buffer information */
+    void        *debug_info;     /* --3 218 Info for debugstr functions */
+    void        *pthread_data;   /* --3 21c Data for pthread emulation */
     /* here is plenty space for wine specific fields (don't forget to change pad6!!) */
 
     /* the following are nt specific fields */
-    DWORD        pad6[631];                  /* --n 21c */
+    DWORD        pad6[630];                  /* --n 220 */
     UNICODE_STRING StaticUnicodeString;      /* -2- bf8 used by advapi32 */
     USHORT       StaticUnicodeBuffer[261];   /* -2- c00 used by advapi32 */
     DWORD        pad7;                       /* --n e0c */

scheduler/client.c

@@ -154,14 +154,15 @@ void *wine_server_alloc_req( size_t fixed_size, size_t var_size )
  */
 static void send_request( enum request req, union generic_request *request )
 {
+    int ret;
+
     request->header.req = req;
     NtCurrentTeb()->buffer_info->cur_req = (char *)request - (char *)NtCurrentTeb()->buffer;
-    /* write a single byte; the value is ignored anyway */
-    if (write( NtCurrentTeb()->request_fd, request, 1 ) == -1)
-    {
+    if ((ret = write( NtCurrentTeb()->request_fd, request, sizeof(*request) )) == sizeof(*request))
+        return;
+    if (ret >= 0) server_protocol_error( "partial write %d\n", ret );
     if (errno == EPIPE) SYSDEPS_ExitThread(0);
     server_protocol_perror( "sendmsg" );
-    }
 }
 
 /***********************************************************************
@@ -176,10 +177,10 @@ static void send_request_fd( enum request req, union generic_request *request, i
 #endif
     struct msghdr msghdr;
     struct iovec vec;
+    int ret;
 
-    /* write a single byte; the value is ignored anyway */
     vec.iov_base = (void *)request;
-    vec.iov_len  = 1;
+    vec.iov_len  = sizeof(*request);
 
     msghdr.msg_name    = NULL;
     msghdr.msg_namelen = 0;
@@ -201,11 +202,10 @@ static void send_request_fd( enum request req, union generic_request *request, i
 
     request->header.req = req;
 
-    if (sendmsg( NtCurrentTeb()->socket, &msghdr, 0 ) == -1)
-    {
+    if ((ret = sendmsg( NtCurrentTeb()->socket, &msghdr, 0 )) == sizeof(*request)) return;
+    if (ret >= 0) server_protocol_error( "partial write %d\n", ret );
     if (errno == EPIPE) SYSDEPS_ExitThread(0);
     server_protocol_perror( "sendmsg" );
-    }
 }
 
 /***********************************************************************
@@ -213,15 +213,16 @@ static void send_request_fd( enum request req, union generic_request *request, i
  *
  * Wait for a reply from the server.
  */
-static void wait_reply(void)
+static void wait_reply( union generic_request *req )
 {
     int ret;
-    char dummy[1];
 
     for (;;)
     {
-        if ((ret = read( NtCurrentTeb()->reply_fd, dummy, 1 )) > 0) return;
+        if ((ret = read( NtCurrentTeb()->reply_fd, req, sizeof(*req) )) == sizeof(*req))
+            return;
         if (!ret) break;
+        if (ret > 0) server_protocol_error( "partial read %d\n", ret );
         if (errno == EINTR) continue;
         if (errno == EPIPE) break;
         server_protocol_perror("read");
@@ -240,7 +241,7 @@ unsigned int wine_server_call( enum request req )
 {
     union generic_request *req_ptr = NtCurrentTeb()->buffer;
     send_request( req, req_ptr );
-    wait_reply();
+    wait_reply( req_ptr );
     return req_ptr->header.error;
 }
 
@@ -256,7 +257,7 @@ unsigned int server_call_fd( enum request req, int fd_out )
     union generic_request *req_ptr = NtCurrentTeb()->buffer;
 
     send_request_fd( req, req_ptr, fd_out );
-    wait_reply();
+    wait_reply( req_ptr );
 
     if ((res = req_ptr->header.error)) SetLastError( RtlNtStatusToDosError(res) );
     return res;  /* error code */
@@ -609,6 +610,10 @@ int CLIENT_InitThread(void)
     if (teb->reply_fd == -1) server_protocol_error( "no reply fd passed on first request\n" );
     fcntl( teb->reply_fd, F_SETFD, 1 ); /* set close on exec flag */
 
+    teb->wait_fd = wine_server_recv_fd( 0, 0 );
+    if (teb->wait_fd == -1) server_protocol_error( "no wait fd passed on first request\n" );
+    fcntl( teb->wait_fd, F_SETFD, 1 ); /* set close on exec flag */
+
     fd = wine_server_recv_fd( 0, 0 );
     if (fd == -1) server_protocol_error( "no fd received for thread buffer\n" );
 
@@ -618,15 +623,16 @@ int CLIENT_InitThread(void)
     if (teb->buffer == (void*)-1) server_protocol_perror( "mmap" );
     teb->buffer_info = (struct server_buffer_info *)((char *)teb->buffer + size) - 1;
 
-    wait_reply();
-
     req = (struct get_thread_buffer_request *)teb->buffer;
+    wait_reply( (union generic_request *)req );
+
     teb->pid = req->pid;
     teb->tid = req->tid;
     if (req->version != SERVER_PROTOCOL_VERSION)
         server_protocol_error( "version mismatch %d/%d.\n"
                                "Your %s binary was not upgraded correctly,\n"
-                               "or you have an older one somewhere in your PATH.\nOr maybe wrong wineserver still running ?",
+                               "or you have an older one somewhere in your PATH.\n"
+                               "Or maybe the wrong wineserver is still running?\n",
                                req->version, SERVER_PROTOCOL_VERSION,
                                (req->version > SERVER_PROTOCOL_VERSION) ? "wine" : "wineserver" );
     if (req->boot) boot_thread_id = teb->tid;

scheduler/synchro.c

@@ -5,10 +5,11 @@
  */
 
 #include <assert.h>
+#include <errno.h>
 #include <signal.h>
 #include <sys/time.h>
 #include <unistd.h>
-#include "heap.h"
+
 #include "file.h"  /* for DOSFS_UnixTimeToFileTime */
 #include "thread.h"
 #include "winerror.h"
@@ -35,6 +36,29 @@ inline static void get_timeout( struct timeval *when, int timeout )
 
 
 /***********************************************************************
+ *              wait_reply
+ *
+ * Wait for a reply on the waiting pipe of the current thread.
+ */
+static int wait_reply(void)
+{
+    int signaled;
+    for (;;)
+    {
+        int ret = read( NtCurrentTeb()->wait_fd, &signaled, sizeof(signaled) );
+        if (ret == sizeof(signaled)) return signaled;
+        if (!ret) break;
+        if (ret > 0) server_protocol_error( "partial wakeup read %d\n", ret );
+        if (errno == EINTR) continue;
+        if (errno == EPIPE) break;
+        server_protocol_perror("read");
+    }
+    /* the server closed the connection; time to die... */
+    SYSDEPS_ExitThread(0);
+}
+
+
+/***********************************************************************
  *              call_apcs
  *
  * Call outstanding APCs.
@@ -166,22 +190,27 @@ DWORD WINAPI WaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
             if (alertable) req->flags |= SELECT_ALERTABLE;
             if (timeout != INFINITE) req->flags |= SELECT_TIMEOUT;
 
-            server_call( REQ_SELECT );
-            ret = req->signaled;
+            ret = server_call_noerr( REQ_SELECT );
         }
         SERVER_END_REQ;
+        if (ret == STATUS_PENDING) ret = wait_reply();
         if (ret != STATUS_USER_APC) break;
         call_apcs( alertable );
         if (alertable) break;
     }
+    if (HIWORD(ret))  /* is it an error code? */
+    {
+        SetLastError( RtlNtStatusToDosError(ret) );
+        ret = WAIT_FAILED;
+    }
     return ret;
 }
 
 
 /***********************************************************************
- *           WIN16_WaitForSingleObject   (KERNEL.460)
+ *           WaitForSingleObject16   (KERNEL.460)
  */
-DWORD WINAPI WIN16_WaitForSingleObject( HANDLE handle, DWORD timeout )
+DWORD WINAPI WaitForSingleObject16( HANDLE handle, DWORD timeout )
 {
     DWORD retval, mutex_count;
 
@@ -192,26 +221,24 @@ DWORD WINAPI WIN16_WaitForSingleObject( HANDLE handle, DWORD timeout )
 }
 
 /***********************************************************************
- *           WIN16_WaitForMultipleObjects   (KERNEL.461)
+ *           WaitForMultipleObjects16   (KERNEL.461)
  */
-DWORD WINAPI WIN16_WaitForMultipleObjects( DWORD count, const HANDLE *handles,
+DWORD WINAPI WaitForMultipleObjects16( DWORD count, const HANDLE *handles,
                                        BOOL wait_all, DWORD timeout )
 {
     DWORD retval, mutex_count;
 
     ReleaseThunkLock( &mutex_count );
-    retval = WaitForMultipleObjects( count, handles, wait_all, timeout );
+    retval = WaitForMultipleObjectsEx( count, handles, wait_all, timeout, FALSE );
     RestoreThunkLock( mutex_count );
     return retval;
 }
 
 /***********************************************************************
- *           WIN16_WaitForMultipleObjectsEx   (KERNEL.495)
+ *           WaitForMultipleObjectsEx16   (KERNEL.495)
  */
-DWORD WINAPI WIN16_WaitForMultipleObjectsEx( DWORD count, 
-                                             const HANDLE *handles,
-                                             BOOL wait_all, DWORD timeout,
-                                             BOOL alertable )
+DWORD WINAPI WaitForMultipleObjectsEx16( DWORD count, const HANDLE *handles,
+                                         BOOL wait_all, DWORD timeout, BOOL alertable )
 {
     DWORD retval, mutex_count;
 
@@ -220,4 +247,3 @@ DWORD WINAPI WIN16_WaitForMultipleObjectsEx( DWORD count,
     RestoreThunkLock( mutex_count );
     return retval;
 }
-

scheduler/thread.c

@@ -93,6 +93,7 @@ static BOOL THREAD_InitTEB( TEB *teb )
     teb->socket    = -1;
     teb->request_fd = -1;
     teb->reply_fd   = -1;
+    teb->wait_fd    = -1;
     teb->stack_top  = (void *)~0UL;
     teb->StaticUnicodeString.MaximumLength = sizeof(teb->StaticUnicodeBuffer);
     teb->StaticUnicodeString.Buffer = (PWSTR)teb->StaticUnicodeBuffer;
@@ -117,6 +118,7 @@ static void CALLBACK THREAD_FreeTEB( TEB *teb )
     if (teb->socket != -1) close( teb->socket );
     close( teb->request_fd );
     close( teb->reply_fd );
+    close( teb->wait_fd );
     if (teb->stack_sel) FreeSelector16( teb->stack_sel );
     FreeSelector16( teb->teb_sel );
     if (teb->buffer) munmap( (void *)teb->buffer,

server/request.c

@@ -129,6 +129,20 @@ void fatal_protocol_error( struct thread *thread, const char *err, ... )
     kill_thread( thread, 1 );
 }
 
+/* complain about a protocol error and terminate the client connection */
+void fatal_protocol_perror( struct thread *thread, const char *err, ... )
+{
+    va_list args;
+
+    va_start( args, err );
+    fprintf( stderr, "Protocol error:%p: ", thread );
+    vfprintf( stderr, err, args );
+    perror( " " );
+    va_end( args );
+    thread->exit_code = 1;
+    kill_thread( thread, 1 );
+}
+
 /* die on a fatal error */
 void fatal_error( const char *err, ... )
 {
@@ -155,20 +169,24 @@ void fatal_perror( const char *err, ... )
 }
 
 /* call a request handler */
-static inline void call_req_handler( struct thread *thread )
+static inline void call_req_handler( struct thread *thread, union generic_request *request )
 {
-    enum request req;
+    enum request req = request->header.req;
+
     current = thread;
     clear_error();
 
-    req = ((struct request_header *)current->buffer)->req;
+    if (debug_level) trace_request( thread, request );
 
-    if (debug_level) trace_request( req );
-
-    if (req < REQ_NB_REQUESTS)
+    if ((unsigned int)request->header.var_offset + request->header.var_size > MAX_REQUEST_LENGTH)
+    {
+        fatal_protocol_error( current, "bad request offset/size %d/%d\n",
+                              request->header.var_offset, request->header.var_size );
+    }
+    else if (req < REQ_NB_REQUESTS)
     {
-        req_handlers[req]( current->buffer );
-        if (current && !current->wait) send_reply( current );
+        req_handlers[req]( request );
+        if (current) send_reply( current, request );
         current = NULL;
         return;
     }
@@ -176,18 +194,32 @@ static inline void call_req_handler( struct thread *thread )
 }
 
 /* send a reply to a thread */
-void send_reply( struct thread *thread )
+void send_reply( struct thread *thread, union generic_request *request )
 {
-    assert( !thread->wait );
-    if (debug_level) trace_reply( thread );
-    if (!write_request( thread )) set_select_events( &thread->obj, POLLOUT );
+    int ret;
+
+    assert (thread->pass_fd == -1);
+
+    if (debug_level) trace_reply( thread, request );
+
+    request->header.error = thread->error;
+
+    if ((ret = write( thread->reply_fd, request, sizeof(*request) )) != sizeof(*request))
+    {
+        if (ret >= 0)
+            fatal_protocol_error( thread, "partial write %d\n", ret );
+        else if (errno == EPIPE)
+            kill_thread( thread, 0 );  /* normal death */
+        else
+            fatal_protocol_perror( thread, "sendmsg" );
+    }
 }
 
 /* read a message from a client that has something to say */
 void read_request( struct thread *thread )
 {
+    union generic_request req;
     int ret;
-    char dummy[1];
 
 #ifdef HAVE_MSGHDR_ACCRIGHTS
     msghdr.msg_accrightslen = sizeof(int);
@@ -200,57 +232,39 @@ void read_request( struct thread *thread )
 
     assert( thread->pass_fd == -1 );
 
-    myiovec.iov_base = dummy;
-    myiovec.iov_len  = 1;
+    myiovec.iov_base = &req;
+    myiovec.iov_len  = sizeof(req);
 
     ret = recvmsg( thread->obj.fd, &msghdr, 0 );
 #ifndef HAVE_MSGHDR_ACCRIGHTS
     thread->pass_fd = cmsg.fd;
 #endif
 
-    if (ret > 0)
+    if (ret == sizeof(req))
     {
-        call_req_handler( thread );
+        call_req_handler( thread, &req );
         thread->pass_fd = -1;
         return;
     }
     if (!ret)  /* closed pipe */
-    {
         kill_thread( thread, 0 );
-        return;
-    }
-    perror("recvmsg");
-    thread->exit_code = 1;
-    kill_thread( thread, 1 );
+    else if (ret > 0)
+        fatal_protocol_error( thread, "partial recvmsg %d\n", ret );
+    else
+        fatal_protocol_perror( thread, "recvmsg" );
 }
 
-/* send a message to a client that is ready to receive something */
-int write_request( struct thread *thread )
+/* send the wakeup signal to a thread */
+int send_thread_wakeup( struct thread *thread, int signaled )
 {
-    int ret;
-    struct request_header *header = thread->buffer;
-
-    header->error = thread->error;
-
-    assert (thread->pass_fd == -1);
-
-    ret = write( thread->reply_fd, header, 1 );
-    if (ret > 0)
-    {
-        set_select_events( &thread->obj, POLLIN );
-        return 1;
-    }
-    if (errno == EWOULDBLOCK) return 0;  /* not a fatal error */
-    if (errno == EPIPE)
-    {
+    int ret = write( thread->wait_fd, &signaled, sizeof(signaled) );
+    if (ret == sizeof(signaled)) return 0;
+    if (ret >= 0)
+        fatal_protocol_error( thread, "partial wakeup write %d\n", ret );
+    else if (errno == EPIPE)
         kill_thread( thread, 0 );  /* normal death */
-    }
     else
-    {
-        perror("sendmsg");
-        thread->exit_code = 1;
-        kill_thread( thread, 1 );
-    }
+        fatal_protocol_perror( thread, "write" );
     return -1;
 }
 
@@ -283,9 +297,7 @@ int send_client_fd( struct thread *thread, int fd, handle_t handle )
     }
     else
     {
-        perror("sendmsg");
-        thread->exit_code = 1;
-        kill_thread( thread, 1 );
+        fatal_protocol_perror( thread, "sendmsg" );
     }
     return -1;
 }
@@ -349,23 +361,20 @@ static void request_socket_poll_event( struct object *obj, int event )
     else if (event & POLLIN)
     {
         struct thread *thread = sock->thread;
+        union generic_request req;
         int ret;
-        char dummy[1];
 
-        ret = read( sock->obj.fd, &dummy, 1 );
-        if (ret > 0)
+        if ((ret = read( sock->obj.fd, &req, sizeof(req) )) == sizeof(req))
         {
-            call_req_handler( thread );
+            call_req_handler( thread, &req );
             return;
         }
         if (!ret)  /* closed pipe */
-        {
             kill_thread( thread, 0 );
-            return;
-        }
-        perror("read");
-        thread->exit_code = 1;
-        kill_thread( thread, 1 );
+        else if (ret > 0)
+            fatal_protocol_error( thread, "partial read %d\n", ret );
+        else
+            fatal_protocol_perror( thread, "read" );
     }
 }
 
@@ -384,6 +393,7 @@ struct object *create_request_socket( struct thread *thread )
     sock->thread = thread;
     send_client_fd( thread, fd[1], 0 );
     close( fd[1] );
+    fcntl( fd[0], F_SETFL, O_NONBLOCK );
     set_select_events( &sock->obj, POLLIN );
     return &sock->obj;
 }

server/request.h

@@ -32,22 +32,16 @@ extern void fatal_error( const char *err, ... ) WINE_NORETURN;
 extern void fatal_perror( const char *err, ... ) WINE_NORETURN;
 extern const char *get_config_dir(void);
 extern void read_request( struct thread *thread );
-extern int write_request( struct thread *thread );
+extern int send_thread_wakeup( struct thread *thread, int signaled );
 extern int send_client_fd( struct thread *thread, int fd, handle_t handle );
-extern void send_reply( struct thread *thread );
+extern void send_reply( struct thread *thread, union generic_request *request );
 extern void open_master_socket(void);
 extern void close_master_socket(void);
 extern void lock_master_socket( int locked );
 extern struct object *create_request_socket( struct thread *thread );
 
-extern void trace_request( enum request req );
-extern void trace_reply( struct thread *thread );
-
-/* get the request buffer */
-static inline void *get_req_ptr( struct thread *thread )
-{
-    return thread->buffer;
-}
+extern void trace_request( struct thread *thread, const union generic_request *request );
+extern void trace_reply( struct thread *thread, const union generic_request *request );
 
 /* get the request vararg data */
 inline static void *get_req_data( const void *req )

server/thread.h

@@ -55,7 +55,8 @@ struct thread
     unsigned int        error;       /* current error code */
     struct object      *request_fd;  /* fd for receiving client requests */
     int                 pass_fd;     /* fd to pass to the client */
-    int                 reply_fd;    /* fd to use to wake a client waiting on a reply */
+    int                 reply_fd;    /* fd to send a reply to a client */
+    int                 wait_fd;     /* fd to use to wake a sleeping client */
     enum run_state      state;     /* running state */
     int                 attached;  /* is thread attached with ptrace? */
     int                 exit_code; /* thread exit code */
@@ -77,9 +78,6 @@ struct thread_snapshot
     int             priority;  /* priority class */
 };
 
-/* callback function for building the thread reply when sleep_on is finished */
-typedef void (*sleep_reply)( struct thread *thread, struct object *obj, int signaled );
-
 extern struct thread *current;
 
 /* thread functions */
@@ -96,8 +94,6 @@ extern int add_queue( struct object *obj, struct wait_queue_entry *entry );
 extern void remove_queue( struct object *obj, struct wait_queue_entry *entry );
 extern void kill_thread( struct thread *thread, int violent_death );
 extern void wake_up( struct object *obj, int max );
-extern int sleep_on( int count, struct object *objects[], int flags,
-                     int sec, int usec, sleep_reply func );
 extern int thread_queue_apc( struct thread *thread, struct object *owner, void *func,
                              enum apc_type type, int system, int nb_args, ... );
 extern void thread_cancel_apc( struct thread *thread, struct object *owner, int system );

server/trace.c

@@ -550,11 +550,6 @@ static void dump_select_request( const struct select_request *req )
     cur_pos += dump_varargs_handles( req );
 }
 
-static void dump_select_reply( const struct select_request *req )
-{
-    fprintf( stderr, " signaled=%d", req->signaled );
-}
-
 static void dump_create_event_request( const struct create_event_request *req )
 {
     fprintf( stderr, " manual_reset=%d,", req->manual_reset );
@@ -1625,7 +1620,7 @@ static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
     (dump_func)dump_set_handle_info_reply,
     (dump_func)dump_dup_handle_reply,
     (dump_func)dump_open_process_reply,
-    (dump_func)dump_select_reply,
+    (dump_func)0,
     (dump_func)dump_create_event_reply,
     (dump_func)0,
     (dump_func)dump_open_event_reply,
@@ -1827,33 +1822,90 @@ static const char * const req_names[REQ_NB_REQUESTS] = {
 /* ### make_requests end ### */
 /* Everything above this line is generated automatically by tools/make_requests */
 
-void trace_request( enum request req )
+static const char *get_status_name( unsigned int status )
+{
+#define NAME(status)  { #status, STATUS_##status }
+    static const struct
+    {
+        const char  *name;
+        unsigned int value;
+    } status_names[] =
+    {
+        NAME(ACCESS_DENIED),
+        NAME(ACCESS_VIOLATION),
+        NAME(BUFFER_OVERFLOW),
+        NAME(CHILD_MUST_BE_VOLATILE),
+        NAME(DIRECTORY_NOT_EMPTY),
+        NAME(DISK_FULL),
+        NAME(FILE_LOCK_CONFLICT),
+        NAME(INVALID_FILE_FOR_SECTION),
+        NAME(INVALID_HANDLE),
+        NAME(INVALID_PARAMETER),
+        NAME(KEY_DELETED),
+        NAME(MEDIA_WRITE_PROTECTED),
+        NAME(MUTANT_NOT_OWNED),
+        NAME(NOT_REGISTRY_FILE),
+        NAME(NO_MEMORY),
+        NAME(NO_MORE_ENTRIES),
+        NAME(NO_MORE_FILES),
+        NAME(NO_SUCH_FILE),
+        NAME(OBJECT_NAME_COLLISION),
+        NAME(OBJECT_NAME_INVALID),
+        NAME(OBJECT_NAME_NOT_FOUND),
+        NAME(OBJECT_PATH_INVALID),
+        NAME(OBJECT_TYPE_MISMATCH),
+        NAME(PENDING),
+        NAME(PIPE_BROKEN),
+        NAME(SEMAPHORE_LIMIT_EXCEEDED),
+        NAME(SHARING_VIOLATION),
+        NAME(SUSPEND_COUNT_EXCEEDED),
+        NAME(TIMEOUT),
+        NAME(TOO_MANY_OPENED_FILES),
+        NAME(UNSUCCESSFUL),
+        NAME(USER_APC),
+        { NULL, 0 }  /* terminator */
+    };
+#undef NAME
+
+    int i;
+    static char buffer[10];
+
+    if (status)
+    {
+        for (i = 0; status_names[i].name; i++)
+            if (status_names[i].value == status) return status_names[i].name;
+    }
+    sprintf( buffer, "%x", status );
+    return buffer;
+}
+
+void trace_request( struct thread *thread, const union generic_request *request )
 {
+    enum request req = request->header.req;
     cur_pos = 0;
     current->last_req = req;
     if (req < REQ_NB_REQUESTS)
     {
-        fprintf( stderr, "%08x: %s(", (unsigned int)current, req_names[req] );
+        fprintf( stderr, "%08x: %s(", (unsigned int)thread, req_names[req] );
         cur_pos = 0;
-        req_dumpers[req]( current->buffer );
+        req_dumpers[req]( request );
     }
     else
-        fprintf( stderr, "%08x: %d(", (unsigned int)current, req );
-    if (current->pass_fd != -1) fprintf( stderr, " ) fd=%d\n", current->pass_fd );
+        fprintf( stderr, "%08x: %d(", (unsigned int)thread, req );
+    if (thread->pass_fd != -1) fprintf( stderr, " ) fd=%d\n", thread->pass_fd );
     else fprintf( stderr, " )\n" );
 }
 
-void trace_reply( struct thread *thread )
+void trace_reply( struct thread *thread, const union generic_request *request )
 {
-    fprintf( stderr, "%08x: %s() = %x",
-             (unsigned int)thread, req_names[thread->last_req], thread->error );
+    fprintf( stderr, "%08x: %s() = %s",
+             (unsigned int)thread, req_names[thread->last_req], get_status_name(thread->error) );
     if (reply_dumpers[thread->last_req])
     {
         fprintf( stderr, " {" );
         cur_pos = 0;
-        reply_dumpers[thread->last_req]( thread->buffer );
+        reply_dumpers[thread->last_req]( request );
         fprintf( stderr, " }" );
     }
-    if (thread->pass_fd != -1) fprintf( stderr, " fd=%d\n", thread->pass_fd );
-    else fprintf( stderr, "\n" );
+    fputc( '\n', stderr );
 }