diff --git a/dlls/kernel/comm.c b/dlls/kernel/comm.c
index 1ea285b..3c6fd9d 100644
--- a/dlls/kernel/comm.c
+++ b/dlls/kernel/comm.c
@@ -2072,11 +2072,10 @@
 
     TRACE("handle %d, mask %p\n", handle, evtmask);
 
-    SERVER_START_REQ
+    SERVER_START_REQ( get_serial_info )
     {
-        struct get_serial_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
-        if ((ret = !server_call( REQ_GET_SERIAL_INFO )))
+        if ((ret = !SERVER_CALL_ERR()))
         {
             if (evtmask) *evtmask = req->eventmask;
         }
@@ -2104,13 +2103,12 @@
 
     TRACE("handle %d, mask %lx\n", handle, evtmask);
 
-    SERVER_START_REQ
+    SERVER_START_REQ( set_serial_info )
     {
-        struct set_serial_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle    = handle;
         req->flags     = SERIALINFO_SET_MASK;
         req->eventmask = evtmask;
-        ret = !server_call( REQ_SET_SERIAL_INFO );
+        ret = !SERVER_CALL_ERR();
     }
     SERVER_END_REQ;
     return ret;
@@ -2677,11 +2675,10 @@
         return FALSE;
     }
 
-    SERVER_START_REQ
+    SERVER_START_REQ( get_serial_info )
     {
-        struct get_serial_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = hComm;
-        if ((ret = !server_call( REQ_GET_SERIAL_INFO )))
+        if ((ret = !SERVER_CALL_ERR()))
         {
             lptimeouts->ReadIntervalTimeout         = req->readinterval;
             lptimeouts->ReadTotalTimeoutMultiplier  = req->readmult;
@@ -2726,9 +2723,8 @@
         return FALSE;
     }
 
-    SERVER_START_REQ
+    SERVER_START_REQ( set_serial_info )
     {
-        struct set_serial_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle       = hComm;
         req->flags        = SERIALINFO_SET_TIMEOUTS;
         req->readinterval = lptimeouts->ReadIntervalTimeout ;
@@ -2736,7 +2732,7 @@
         req->readconst    = lptimeouts->ReadTotalTimeoutConstant ;
         req->writemult    = lptimeouts->WriteTotalTimeoutMultiplier ;
         req->writeconst   = lptimeouts->WriteTotalTimeoutConstant ;
-        ret = !server_call( REQ_SET_SERIAL_INFO );
+        ret = !SERVER_CALL_ERR();
     }
     SERVER_END_REQ;
     if (!ret) return FALSE;
@@ -2886,10 +2882,8 @@
     lpov->OffsetHigh = 0;
 
     /* start an ASYNCHRONOUS WaitCommEvent */
-    SERVER_START_REQ
+    SERVER_START_REQ( create_async )
     {
-        struct create_async_request *req = server_alloc_req( sizeof(*req), 0 );
-
         req->file_handle = hFile;
         req->overlapped  = lpov;
         req->buffer = lpdwEvents;
@@ -2897,7 +2891,7 @@
         req->func = COMM_WaitCommEventService;
         req->type = ASYNC_TYPE_WAIT;
 
-        ret=server_call( REQ_CREATE_ASYNC );
+        ret=SERVER_CALL_ERR();
 
         lpov->InternalHigh = req->ov_handle;
     }
diff --git a/dlls/kernel/debugger.c b/dlls/kernel/debugger.c
index cfcb1c4..3747156 100644
--- a/dlls/kernel/debugger.c
+++ b/dlls/kernel/debugger.c
@@ -36,13 +36,11 @@
     for (;;)
     {
         HANDLE wait = 0;
-        SERVER_START_REQ
+        debug_event_t *data;
+        SERVER_START_VAR_REQ( wait_debug_event, sizeof(*data) )
         {
-            debug_event_t *data;
-            struct wait_debug_event_request *req = server_alloc_req( sizeof(*req), sizeof(*data) );
-
             req->get_handle = (timeout != 0);
-            if (!(ret = !server_call( REQ_WAIT_DEBUG_EVENT ))) goto done;
+            if (!(ret = !SERVER_CALL_ERR())) goto done;
 
             if (!server_data_size(req))  /* timeout */
             {
@@ -108,7 +106,7 @@
             }
         done:
         }
-        SERVER_END_REQ;
+        SERVER_END_VAR_REQ;
         if (ret) return TRUE;
         if (!wait) break;
         res = WaitForSingleObject( wait, timeout );
@@ -137,13 +135,12 @@
     DWORD status) /* [in] The rule to apply to unhandled exeptions. */
 {
     BOOL ret;
-    SERVER_START_REQ
+    SERVER_START_REQ( continue_debug_event )
     {
-        struct continue_debug_event_request *req = server_alloc_req( sizeof(*req), 0 );
         req->pid    = (void *)pid;
         req->tid    = (void *)tid;
         req->status = status;
-        ret = !server_call( REQ_CONTINUE_DEBUG_EVENT );
+        ret = !SERVER_CALL_ERR();
     }
     SERVER_END_REQ;
     return ret;
@@ -163,11 +160,10 @@
     DWORD pid) /* [in] The process to be debugged. */
 {
     BOOL ret;
-    SERVER_START_REQ
+    SERVER_START_REQ( debug_process )
     {
-        struct debug_process_request *req = server_alloc_req( sizeof(*req), 0 );
         req->pid = (void *)pid;
-        ret = !server_call( REQ_DEBUG_PROCESS );
+        ret = !SERVER_CALL_ERR();
     }
     SERVER_END_REQ;
     return ret;
@@ -184,13 +180,12 @@
 void WINAPI OutputDebugStringA(
     LPCSTR str) /* [in] The message to be logged and given to the debugger. */
 {
-    SERVER_START_REQ
+    SERVER_START_REQ( output_debug_string )
     {
-        struct output_debug_string_request *req = server_alloc_req( sizeof(*req), 0 );
         req->string  = (void *)str;
         req->unicode = 0;
         req->length  = strlen(str) + 1;
-        server_call_noerr( REQ_OUTPUT_DEBUG_STRING );
+        SERVER_CALL();
     }
     SERVER_END_REQ;
     WARN("%s\n", str);
@@ -206,13 +201,12 @@
 void WINAPI OutputDebugStringW(
     LPCWSTR str) /* [in] The message to be logged and given to the debugger. */
 {
-    SERVER_START_REQ
+    SERVER_START_REQ( output_debug_string )
     {
-        struct output_debug_string_request *req = server_alloc_req( sizeof(*req), 0 );
         req->string  = (void *)str;
         req->unicode = 1;
         req->length  = (lstrlenW(str) + 1) * sizeof(WCHAR);
-        server_call_noerr( REQ_OUTPUT_DEBUG_STRING );
+        SERVER_CALL();
     }
     SERVER_END_REQ;
     WARN("%s\n", debugstr_w(str));
@@ -282,11 +276,10 @@
 BOOL WINAPI IsDebuggerPresent(void)
 {
     BOOL ret = FALSE;
-    SERVER_START_REQ
+    SERVER_START_REQ( get_process_info )
     {
-        struct get_process_info_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = GetCurrentProcess();
-        if (!server_call( REQ_GET_PROCESS_INFO )) ret = req->debugged;
+        if (!SERVER_CALL_ERR()) ret = req->debugged;
     }
     SERVER_END_REQ;
     return ret;
diff --git a/dlls/kernel/sync.c b/dlls/kernel/sync.c
index 1c5ff98..1c924d3 100644
--- a/dlls/kernel/sync.c
+++ b/dlls/kernel/sync.c
@@ -31,19 +31,17 @@
         SetLastError( ERROR_FILENAME_EXCED_RANGE );
         return 0;
     }
-    SERVER_START_REQ
+    SERVER_START_VAR_REQ( create_event, len * sizeof(WCHAR) )
     {
-        struct create_event_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
-
         req->manual_reset = manual_reset;
         req->initial_state = initial_state;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
         if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
         SetLastError(0);
-        server_call( REQ_CREATE_EVENT );
+        SERVER_CALL_ERR();
         ret = req->handle;
     }
-    SERVER_END_REQ;
+    SERVER_END_VAR_REQ;
     return ret;
 }
 
@@ -70,19 +68,17 @@
         SetLastError( ERROR_INVALID_PARAMETER);
         return 0;
     }
-    SERVER_START_REQ
+    SERVER_START_VAR_REQ( create_event, len * sizeof(WCHAR) )
     {
-        struct create_event_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
-
         req->manual_reset = manual_reset;
         req->initial_state = initial_state;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
         memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
         SetLastError(0);
-        server_call( REQ_CREATE_EVENT );
+        SERVER_CALL_ERR();
         ret = req->handle;
     }
-    SERVER_END_REQ;
+    SERVER_END_VAR_REQ;
     return ret;
 }
 
@@ -108,17 +104,15 @@
         SetLastError( ERROR_FILENAME_EXCED_RANGE );
         return 0;
     }
-    SERVER_START_REQ
+    SERVER_START_VAR_REQ( open_event, len * sizeof(WCHAR) )
     {
-        struct open_event_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
-
         req->access  = access;
         req->inherit = inherit;
         if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
-        server_call( REQ_OPEN_EVENT );
+        SERVER_CALL_ERR();
         ret = req->handle;
     }
-    SERVER_END_REQ;
+    SERVER_END_VAR_REQ;
     return ret;
 }
 
@@ -135,17 +129,15 @@
         SetLastError( ERROR_FILENAME_EXCED_RANGE );
         return 0;
     }
-    SERVER_START_REQ
+    SERVER_START_VAR_REQ( open_event, len * sizeof(WCHAR) )
     {
-        struct open_event_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
-
         req->access  = access;
         req->inherit = inherit;
         memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
-        server_call( REQ_OPEN_EVENT );
+        SERVER_CALL_ERR();
         ret = req->handle;
     }
-    SERVER_END_REQ;
+    SERVER_END_VAR_REQ;
     return ret;
 }
 
@@ -158,12 +150,11 @@
 static BOOL EVENT_Operation( HANDLE handle, enum event_op op )
 {
     BOOL ret;
-    SERVER_START_REQ
+    SERVER_START_REQ( event_op )
     {
-        struct event_op_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
         req->op     = op;
-        ret = !server_call( REQ_EVENT_OP );
+        ret = !SERVER_CALL_ERR();
     }
     SERVER_END_REQ;
     return ret;
@@ -257,18 +248,16 @@
         SetLastError( ERROR_FILENAME_EXCED_RANGE );
         return 0;
     }
-    SERVER_START_REQ
+    SERVER_START_VAR_REQ( create_mutex, len * sizeof(WCHAR) )
     {
-        struct create_mutex_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
-
         req->owned   = owner;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
         if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
         SetLastError(0);
-        server_call( REQ_CREATE_MUTEX );
+        SERVER_CALL_ERR();
         ret = req->handle;
     }
-    SERVER_END_REQ;
+    SERVER_END_VAR_REQ;
     return ret;
 }
 
@@ -285,18 +274,16 @@
         SetLastError( ERROR_FILENAME_EXCED_RANGE );
         return 0;
     }
-    SERVER_START_REQ
+    SERVER_START_VAR_REQ( create_mutex, len * sizeof(WCHAR) )
     {
-        struct create_mutex_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
-
         req->owned   = owner;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
         memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
         SetLastError(0);
-        server_call( REQ_CREATE_MUTEX );
+        SERVER_CALL_ERR();
         ret = req->handle;
     }
-    SERVER_END_REQ;
+    SERVER_END_VAR_REQ;
     return ret;
 }
 
@@ -318,17 +305,15 @@
         SetLastError( ERROR_FILENAME_EXCED_RANGE );
         return 0;
     }
-    SERVER_START_REQ
+    SERVER_START_VAR_REQ( open_mutex, len * sizeof(WCHAR) )
     {
-        struct open_mutex_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
-
         req->access  = access;
         req->inherit = inherit;
         if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
-        server_call( REQ_OPEN_MUTEX );
+        SERVER_CALL_ERR();
         ret = req->handle;
     }
-    SERVER_END_REQ;
+    SERVER_END_VAR_REQ;
     return ret;
 }
 
@@ -345,17 +330,15 @@
         SetLastError( ERROR_FILENAME_EXCED_RANGE );
         return 0;
     }
-    SERVER_START_REQ
+    SERVER_START_VAR_REQ( open_mutex, len * sizeof(WCHAR) )
     {
-        struct open_mutex_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
-
         req->access  = access;
         req->inherit = inherit;
         memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
-        server_call( REQ_OPEN_MUTEX );
+        SERVER_CALL_ERR();
         ret = req->handle;
     }
-    SERVER_END_REQ;
+    SERVER_END_VAR_REQ;
     return ret;
 }
 
@@ -366,11 +349,10 @@
 BOOL WINAPI ReleaseMutex( HANDLE handle )
 {
     BOOL ret;
-    SERVER_START_REQ
+    SERVER_START_REQ( release_mutex )
     {
-        struct release_mutex_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
-        ret = !server_call( REQ_RELEASE_MUTEX );
+        ret = !SERVER_CALL_ERR();
     }
     SERVER_END_REQ;
     return ret;
@@ -403,20 +385,17 @@
         return 0;
     }
 
-    SERVER_START_REQ
+    SERVER_START_VAR_REQ( create_semaphore, len * sizeof(WCHAR) )
     {
-        struct create_semaphore_request *req = server_alloc_req( sizeof(*req),
-                                                                 len * sizeof(WCHAR) );
-
         req->initial = (unsigned int)initial;
         req->max     = (unsigned int)max;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
         if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
         SetLastError(0);
-        server_call( REQ_CREATE_SEMAPHORE );
+        SERVER_CALL_ERR();
         ret = req->handle;
     }
-    SERVER_END_REQ;
+    SERVER_END_VAR_REQ;
     return ret;
 }
 
@@ -443,20 +422,17 @@
         return 0;
     }
 
-    SERVER_START_REQ
+    SERVER_START_VAR_REQ( create_semaphore, len * sizeof(WCHAR) )
     {
-        struct create_semaphore_request *req = server_alloc_req( sizeof(*req),
-                                                                 len * sizeof(WCHAR) );
-
         req->initial = (unsigned int)initial;
         req->max     = (unsigned int)max;
         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
         memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
         SetLastError(0);
-        server_call( REQ_CREATE_SEMAPHORE );
+        SERVER_CALL_ERR();
         ret = req->handle;
     }
-    SERVER_END_REQ;
+    SERVER_END_VAR_REQ;
     return ret;
 }
 
@@ -473,17 +449,15 @@
         SetLastError( ERROR_FILENAME_EXCED_RANGE );
         return 0;
     }
-    SERVER_START_REQ
+    SERVER_START_VAR_REQ( open_semaphore, len * sizeof(WCHAR) )
     {
-        struct open_semaphore_request *req = server_alloc_req( sizeof(*req),
-                                                               len * sizeof(WCHAR) );
         req->access  = access;
         req->inherit = inherit;
         if (len) MultiByteToWideChar( CP_ACP, 0, name, strlen(name), server_data_ptr(req), len );
-        server_call( REQ_OPEN_SEMAPHORE );
+        SERVER_CALL_ERR();
         ret = req->handle;
     }
-    SERVER_END_REQ;
+    SERVER_END_VAR_REQ;
     return ret;
 }
 
@@ -500,16 +474,15 @@
         SetLastError( ERROR_FILENAME_EXCED_RANGE );
         return 0;
     }
-    SERVER_START_REQ
+    SERVER_START_VAR_REQ( open_semaphore, len * sizeof(WCHAR) )
     {
-        struct open_semaphore_request *req = server_alloc_req( sizeof(*req), len * sizeof(WCHAR) );
         req->access  = access;
         req->inherit = inherit;
         memcpy( server_data_ptr(req), name, len * sizeof(WCHAR) );
-        server_call( REQ_OPEN_SEMAPHORE );
+        SERVER_CALL_ERR();
         ret = req->handle;
     }
-    SERVER_END_REQ;
+    SERVER_END_VAR_REQ;
     return ret;
 }
 
diff --git a/dlls/kernel/toolhelp.c b/dlls/kernel/toolhelp.c
index a0110c4..2702553 100644
--- a/dlls/kernel/toolhelp.c
+++ b/dlls/kernel/toolhelp.c
@@ -202,13 +202,12 @@
     }
 
     /* Now do the snapshot */
-    SERVER_START_REQ
+    SERVER_START_REQ( create_snapshot )
     {
-        struct create_snapshot_request *req = server_alloc_req( sizeof(*req), 0 );
         req->flags   = flags & ~TH32CS_INHERIT;
         req->inherit = (flags & TH32CS_INHERIT) != 0;
         req->pid     = (void *)process;
-        server_call( REQ_CREATE_SNAPSHOT );
+        SERVER_CALL_ERR();
         ret = req->handle;
     }
     SERVER_END_REQ;
@@ -232,12 +231,11 @@
         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(THREADENTRY32), lpte->dwSize);
         return FALSE;
     }
-    SERVER_START_REQ
+    SERVER_START_REQ( next_thread )
     {
-        struct next_thread_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
         req->reset = first;
-        if ((ret = !server_call( REQ_NEXT_THREAD )))
+        if ((ret = !SERVER_CALL_ERR()))
         {
             lpte->cntUsage           = req->count;
             lpte->th32ThreadID       = (DWORD)req->tid;
@@ -286,12 +284,11 @@
         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(PROCESSENTRY32), lppe->dwSize);
         return FALSE;
     }
-    SERVER_START_REQ
+    SERVER_START_REQ( next_process )
     {
-        struct next_process_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
         req->reset = first;
-        if ((ret = !server_call( REQ_NEXT_PROCESS )))
+        if ((ret = !SERVER_CALL_ERR()))
         {
             lppe->cntUsage            = req->count;
             lppe->th32ProcessID       = (DWORD)req->pid;
@@ -345,12 +342,11 @@
         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(MODULEENTRY32), lpme->dwSize);
         return FALSE;
     }
-    SERVER_START_REQ
+    SERVER_START_REQ( next_module )
     {
-        struct next_module_request *req = server_alloc_req( sizeof(*req), 0 );
         req->handle = handle;
         req->reset = first;
-        if ((ret = !server_call( REQ_NEXT_MODULE )))
+        if ((ret = !SERVER_CALL_ERR()))
         {
             lpme->th32ModuleID   = 0;  /* toolhelp internal id, never used */
             lpme->th32ProcessID  = (DWORD)req->pid;