git.oblomov.eu Git - wine/blob - server/trace.c

   1 /*
   2  * Server request tracing
   3  *
   4  * Copyright (C) 1999 Alexandre Julliard
   5  */
   6
   7 #include <ctype.h>
   8 #include <stdio.h>
   9 #include <sys/types.h>
  10 #include <sys/uio.h>
  11 #include "winsock2.h"
  12 #include "winnt.h"
  13 #include "winbase.h"
  14 #include "wincon.h"
  15 #include "request.h"
  16 #include "unicode.h"
  17
  18 static int cur_pos;
  19
  20 /* utility functions */
  21
  22 static const void *get_data( const void *req )
  23 {
  24     return (char *)get_req_data(req) + cur_pos;
  25 }
  26
  27 static size_t get_size( const void *req )
  28 {
  29     return get_req_data_size(req) - cur_pos;
  30 }
  31
  32 static void dump_uints( const int *ptr, int len )
  33 {
  34     fputc( '{', stderr );
  35     while (len > 0)
  36     {
  37         fprintf( stderr, "%08x", *ptr++ );
  38         if (--len) fputc( ',', stderr );
  39     }
  40     fputc( '}', stderr );
  41 }
  42
  43 static void dump_bytes( const unsigned char *ptr, int len )
  44 {
  45     fputc( '{', stderr );
  46     while (len > 0)
  47     {
  48         fprintf( stderr, "%02x", *ptr++ );
  49         if (--len) fputc( ',', stderr );
  50     }
  51     fputc( '}', stderr );
  52 }
  53
  54 static void dump_path_t( const void *req, const path_t *path )
  55 {
  56     const WCHAR *str = *path;
  57     size_t len = get_req_strlenW( req, str );
  58     fprintf( stderr, "L\"" );
  59     dump_strW( str, len, stderr, "\"\"" );
  60     fputc( '\"', stderr );
  61 }
  62
  63 static void dump_context( const CONTEXT *context )
  64 {
  65 #ifdef __i386__
  66     fprintf( stderr, "{flags=%08lx,eax=%08lx,ebx=%08lx,ecx=%08lx,edx=%08lx,esi=%08lx,edi=%08lx,"
  67              "ebp=%08lx,eip=%08lx,esp=%08lx,eflags=%08lx,cs=%04lx,ds=%04lx,es=%04lx,"
  68              "fs=%04lx,gs=%04lx,dr0=%08lx,dr1=%08lx,dr2=%08lx,dr3=%08lx,dr6=%08lx,dr7=%08lx,",
  69              context->ContextFlags, context->Eax, context->Ebx, context->Ecx, context->Edx,
  70              context->Esi, context->Edi, context->Ebp, context->Eip, context->Esp, context->EFlags,
  71              context->SegCs, context->SegDs, context->SegEs, context->SegFs, context->SegGs,
  72              context->Dr0, context->Dr1, context->Dr2, context->Dr3, context->Dr6, context->Dr7 );
  73     fprintf( stderr, "float=" );
  74     dump_uints( (int *)&context->FloatSave, sizeof(context->FloatSave) / sizeof(int) );
  75     fprintf( stderr, "}" );
  76 #else
  77     dump_uints( (int *)context, sizeof(*context) / sizeof(int) );
  78 #endif
  79 }
  80
  81 static void dump_exc_record( const EXCEPTION_RECORD *rec )
  82 {
  83     int i;
  84     fprintf( stderr, "{code=%lx,flags=%lx,rec=%p,addr=%p,params={",
  85              rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionRecord,
  86              rec->ExceptionAddress );
  87     for (i = 0; i < min(rec->NumberParameters,EXCEPTION_MAXIMUM_PARAMETERS); i++)
  88     {
  89         if (i) fputc( ',', stderr );
  90         fprintf( stderr, "%lx", rec->ExceptionInformation[i] );
  91     }
  92     fputc( '}', stderr );
  93 }
  94
  95 static size_t dump_varargs_ints( const void *req )
  96 {
  97     const int *data = get_data(req);
  98     size_t len = get_size(req) / sizeof(*data);
  99
 100     fputc( '{', stderr );
 101     while (len > 0)
 102     {
 103         fprintf( stderr, "%d", *data++ );
 104         if (--len) fputc( ',', stderr );
 105     }
 106     fputc( '}', stderr );
 107     return get_size(req);
 108 }
 109
 110 static size_t dump_varargs_ptrs( const void *req )
 111 {
 112     void * const *data = get_data(req);
 113     size_t len = get_size(req) / sizeof(*data);
 114
 115     fputc( '{', stderr );
 116     while (len > 0)
 117     {
 118         fprintf( stderr, "%p", *data++ );
 119         if (--len) fputc( ',', stderr );
 120     }
 121     fputc( '}', stderr );
 122     return get_size(req);
 123 }
 124
 125 static size_t dump_varargs_bytes( const void *req )
 126 {
 127     const unsigned char *data = get_data(req);
 128     size_t len = get_size(req);
 129
 130     fputc( '{', stderr );
 131     while (len > 0)
 132     {
 133         fprintf( stderr, "%02x", *data++ );
 134         if (--len) fputc( ',', stderr );
 135     }
 136     fputc( '}', stderr );
 137     return get_size(req);
 138 }
 139
 140 static size_t dump_varargs_string( const void *req )
 141 {
 142     fprintf( stderr, "\"%.*s\"", (int)get_size(req), (char *)get_data(req) );
 143     return get_size(req);
 144 }
 145
 146 static size_t dump_varargs_unicode_len_str( const void *req )
 147 {
 148     const WCHAR *str = get_data(req);
 149     int len = *str++ + sizeof(WCHAR);
 150     len = min( len, get_size(req) );
 151     fprintf( stderr, "L\"" );
 152     if (len >= sizeof(WCHAR)) dump_strW( str, (len / sizeof(WCHAR)) - 1, stderr, "\"\"" );
 153     fputc( '\"', stderr );
 154     return len;
 155 }
 156
 157 static size_t dump_varargs_unicode_str( const void *req )
 158 {
 159     fprintf( stderr, "L\"" );
 160     dump_strW( get_data(req), get_size(req) / sizeof(WCHAR), stderr, "\"\"" );
 161     fputc( '\"', stderr );
 162     return get_size(req);
 163 }
 164
 165 static size_t dump_varargs_context( const void *req )
 166 {
 167     dump_context( get_data(req) );
 168     return get_size(req);
 169 }
 170
 171 static size_t dump_varargs_exc_event( const void *req )
 172 {
 173     const CONTEXT *ptr = get_data(req);
 174     fprintf( stderr, "{context=" );
 175     dump_context( ptr );
 176     fprintf( stderr, ",rec=" );
 177     dump_exc_record( (EXCEPTION_RECORD *)(ptr + 1) );
 178     fputc( '}', stderr );
 179     return get_size(req);
 180 }
 181
 182 static size_t dump_varargs_debug_event( const void *req )
 183 {
 184     const debug_event_t *event = get_data(req);
 185
 186     if (!get_size(req))
 187     {
 188         fprintf( stderr, "{}" );
 189         return 0;
 190     }
 191     switch(event->code)
 192     {
 193     case EXCEPTION_DEBUG_EVENT:
 194         fprintf( stderr, "{exception," );
 195         dump_exc_record( &event->info.exception.record );
 196         fprintf( stderr, ",first=%d}", event->info.exception.first );
 197         break;
 198     case CREATE_THREAD_DEBUG_EVENT:
 199         fprintf( stderr, "{create_thread,thread=%d,teb=%p,start=%p}",
 200                  event->info.create_thread.handle, event->info.create_thread.teb,
 201                  event->info.create_thread.start );
 202         break;
 203     case CREATE_PROCESS_DEBUG_EVENT:
 204         fprintf( stderr, "{create_process,file=%d,process=%d,thread=%d,base=%p,offset=%d,"
 205                          "size=%d,teb=%p,start=%p,name=%p,unicode=%d}",
 206                  event->info.create_process.file, event->info.create_process.process,
 207                  event->info.create_process.thread, event->info.create_process.base,
 208                  event->info.create_process.dbg_offset, event->info.create_process.dbg_size,
 209                  event->info.create_process.teb, event->info.create_process.start,
 210                  event->info.create_process.name, event->info.create_process.unicode );
 211         break;
 212     case EXIT_THREAD_DEBUG_EVENT:
 213         fprintf( stderr, "{exit_thread,code=%d}", event->info.exit.exit_code );
 214         break;
 215     case EXIT_PROCESS_DEBUG_EVENT:
 216         fprintf( stderr, "{exit_process,code=%d}", event->info.exit.exit_code );
 217         break;
 218     case LOAD_DLL_DEBUG_EVENT:
 219         fprintf( stderr, "{load_dll,file=%d,base=%p,offset=%d,size=%d,name=%p,unicode=%d}",
 220                  event->info.load_dll.handle, event->info.load_dll.base,
 221                  event->info.load_dll.dbg_offset, event->info.load_dll.dbg_size,
 222                  event->info.load_dll.name, event->info.load_dll.unicode );
 223         break;
 224     case UNLOAD_DLL_DEBUG_EVENT:
 225         fprintf( stderr, "{unload_dll,base=%p}", event->info.unload_dll.base );
 226         break;
 227     case OUTPUT_DEBUG_STRING_EVENT:
 228         fprintf( stderr, "{output_string,data=%p,unicode=%d,len=%d}",
 229                  event->info.output_string.string, event->info.output_string.unicode,
 230                  event->info.output_string.length );
 231         break;
 232     case RIP_EVENT:
 233         fprintf( stderr, "{rip,err=%d,type=%d}",
 234                  event->info.rip_info.error, event->info.rip_info.type );
 235         break;
 236     case 0:  /* zero is the code returned on timeouts */
 237         fprintf( stderr, "{}" );
 238         break;
 239     default:
 240         fprintf( stderr, "{code=??? (%d)}", event->code );
 241         break;
 242     }
 243     return get_size(req);
 244 }
 245
 246 static size_t dump_varargs_input_records( const void *req )
 247 {
 248     const INPUT_RECORD *rec = get_data(req);
 249     size_t len = get_size(req) / sizeof(*rec);
 250
 251     fputc( '{', stderr );
 252     while (len > 0)
 253     {
 254         fprintf( stderr, "{%04x,...}", rec->EventType );
 255         rec++;
 256         if (--len) fputc( ',', stderr );
 257     }
 258     fputc( '}', stderr );
 259     return get_size(req);
 260 }
 261
 262 /* dumping for functions for requests that have a variable part */
 263
 264 static void dump_varargs_enum_key_value_reply( const struct enum_key_value_request *req )
 265 {
 266     int count = min( req->len - req->offset, get_req_size( req, req->data, 1 ));
 267     dump_bytes( req->data, count );
 268 }
 269
 270 typedef void (*dump_func)( const void *req );
 271
 272 /* Everything below this line is generated automatically by tools/make_requests */
 273 /* ### make_requests begin ### */
 274
 275 static void dump_new_process_request( const struct new_process_request *req )
 276 {
 277     fprintf( stderr, " inherit_all=%d,", req->inherit_all );
 278     fprintf( stderr, " create_flags=%d,", req->create_flags );
 279     fprintf( stderr, " start_flags=%d,", req->start_flags );
 280     fprintf( stderr, " exe_file=%d,", req->exe_file );
 281     fprintf( stderr, " hstdin=%d,", req->hstdin );
 282     fprintf( stderr, " hstdout=%d,", req->hstdout );
 283     fprintf( stderr, " hstderr=%d,", req->hstderr );
 284     fprintf( stderr, " cmd_show=%d,", req->cmd_show );
 285     fprintf( stderr, " alloc_fd=%d,", req->alloc_fd );
 286     fprintf( stderr, " filename=" );
 287     cur_pos += dump_varargs_string( req );
 288 }
 289
 290 static void dump_wait_process_request( const struct wait_process_request *req )
 291 {
 292     fprintf( stderr, " pinherit=%d,", req->pinherit );
 293     fprintf( stderr, " tinherit=%d,", req->tinherit );
 294     fprintf( stderr, " timeout=%d,", req->timeout );
 295     fprintf( stderr, " cancel=%d", req->cancel );
 296 }
 297
 298 static void dump_wait_process_reply( const struct wait_process_request *req )
 299 {
 300     fprintf( stderr, " pid=%p,", req->pid );
 301     fprintf( stderr, " phandle=%d,", req->phandle );
 302     fprintf( stderr, " tid=%p,", req->tid );
 303     fprintf( stderr, " thandle=%d,", req->thandle );
 304     fprintf( stderr, " event=%d", req->event );
 305 }
 306
 307 static void dump_new_thread_request( const struct new_thread_request *req )
 308 {
 309     fprintf( stderr, " suspend=%d,", req->suspend );
 310     fprintf( stderr, " inherit=%d", req->inherit );
 311 }
 312
 313 static void dump_new_thread_reply( const struct new_thread_request *req )
 314 {
 315     fprintf( stderr, " tid=%p,", req->tid );
 316     fprintf( stderr, " handle=%d", req->handle );
 317 }
 318
 319 static void dump_boot_done_request( const struct boot_done_request *req )
 320 {
 321     fprintf( stderr, " debug_level=%d", req->debug_level );
 322 }
 323
 324 static void dump_init_process_request( const struct init_process_request *req )
 325 {
 326     fprintf( stderr, " ldt_copy=%p,", req->ldt_copy );
 327     fprintf( stderr, " ldt_flags=%p,", req->ldt_flags );
 328     fprintf( stderr, " ppid=%d", req->ppid );
 329 }
 330
 331 static void dump_init_process_reply( const struct init_process_request *req )
 332 {
 333     fprintf( stderr, " start_flags=%d,", req->start_flags );
 334     fprintf( stderr, " server_start=%08x,", req->server_start );
 335     fprintf( stderr, " exe_file=%d,", req->exe_file );
 336     fprintf( stderr, " hstdin=%d,", req->hstdin );
 337     fprintf( stderr, " hstdout=%d,", req->hstdout );
 338     fprintf( stderr, " hstderr=%d,", req->hstderr );
 339     fprintf( stderr, " cmd_show=%d,", req->cmd_show );
 340     fprintf( stderr, " filename=" );
 341     cur_pos += dump_varargs_string( req );
 342 }
 343
 344 static void dump_init_process_done_request( const struct init_process_done_request *req )
 345 {
 346     fprintf( stderr, " module=%p,", req->module );
 347     fprintf( stderr, " entry=%p,", req->entry );
 348     fprintf( stderr, " name=%p,", req->name );
 349     fprintf( stderr, " gui=%d", req->gui );
 350 }
 351
 352 static void dump_init_process_done_reply( const struct init_process_done_request *req )
 353 {
 354     fprintf( stderr, " debugged=%d", req->debugged );
 355 }
 356
 357 static void dump_init_thread_request( const struct init_thread_request *req )
 358 {
 359     fprintf( stderr, " unix_pid=%d,", req->unix_pid );
 360     fprintf( stderr, " teb=%p,", req->teb );
 361     fprintf( stderr, " entry=%p", req->entry );
 362 }
 363
 364 static void dump_get_thread_buffer_request( const struct get_thread_buffer_request *req )
 365 {
 366 }
 367
 368 static void dump_get_thread_buffer_reply( const struct get_thread_buffer_request *req )
 369 {
 370     fprintf( stderr, " pid=%p,", req->pid );
 371     fprintf( stderr, " tid=%p,", req->tid );
 372     fprintf( stderr, " boot=%d,", req->boot );
 373     fprintf( stderr, " version=%d", req->version );
 374 }
 375
 376 static void dump_terminate_process_request( const struct terminate_process_request *req )
 377 {
 378     fprintf( stderr, " handle=%d,", req->handle );
 379     fprintf( stderr, " exit_code=%d", req->exit_code );
 380 }
 381
 382 static void dump_terminate_process_reply( const struct terminate_process_request *req )
 383 {
 384     fprintf( stderr, " self=%d", req->self );
 385 }
 386
 387 static void dump_terminate_thread_request( const struct terminate_thread_request *req )
 388 {
 389     fprintf( stderr, " handle=%d,", req->handle );
 390     fprintf( stderr, " exit_code=%d", req->exit_code );
 391 }
 392
 393 static void dump_terminate_thread_reply( const struct terminate_thread_request *req )
 394 {
 395     fprintf( stderr, " self=%d,", req->self );
 396     fprintf( stderr, " last=%d", req->last );
 397 }
 398
 399 static void dump_get_process_info_request( const struct get_process_info_request *req )
 400 {
 401     fprintf( stderr, " handle=%d", req->handle );
 402 }
 403
 404 static void dump_get_process_info_reply( const struct get_process_info_request *req )
 405 {
 406     fprintf( stderr, " pid=%p,", req->pid );
 407     fprintf( stderr, " debugged=%d,", req->debugged );
 408     fprintf( stderr, " exit_code=%d,", req->exit_code );
 409     fprintf( stderr, " priority=%d,", req->priority );
 410     fprintf( stderr, " process_affinity=%d,", req->process_affinity );
 411     fprintf( stderr, " system_affinity=%d", req->system_affinity );
 412 }
 413
 414 static void dump_set_process_info_request( const struct set_process_info_request *req )
 415 {
 416     fprintf( stderr, " handle=%d,", req->handle );
 417     fprintf( stderr, " mask=%d,", req->mask );
 418     fprintf( stderr, " priority=%d,", req->priority );
 419     fprintf( stderr, " affinity=%d", req->affinity );
 420 }
 421
 422 static void dump_get_thread_info_request( const struct get_thread_info_request *req )
 423 {
 424     fprintf( stderr, " handle=%d,", req->handle );
 425     fprintf( stderr, " tid_in=%p", req->tid_in );
 426 }
 427
 428 static void dump_get_thread_info_reply( const struct get_thread_info_request *req )
 429 {
 430     fprintf( stderr, " tid=%p,", req->tid );
 431     fprintf( stderr, " teb=%p,", req->teb );
 432     fprintf( stderr, " exit_code=%d,", req->exit_code );
 433     fprintf( stderr, " priority=%d", req->priority );
 434 }
 435
 436 static void dump_set_thread_info_request( const struct set_thread_info_request *req )
 437 {
 438     fprintf( stderr, " handle=%d,", req->handle );
 439     fprintf( stderr, " mask=%d,", req->mask );
 440     fprintf( stderr, " priority=%d,", req->priority );
 441     fprintf( stderr, " affinity=%d", req->affinity );
 442 }
 443
 444 static void dump_suspend_thread_request( const struct suspend_thread_request *req )
 445 {
 446     fprintf( stderr, " handle=%d", req->handle );
 447 }
 448
 449 static void dump_suspend_thread_reply( const struct suspend_thread_request *req )
 450 {
 451     fprintf( stderr, " count=%d", req->count );
 452 }
 453
 454 static void dump_resume_thread_request( const struct resume_thread_request *req )
 455 {
 456     fprintf( stderr, " handle=%d", req->handle );
 457 }
 458
 459 static void dump_resume_thread_reply( const struct resume_thread_request *req )
 460 {
 461     fprintf( stderr, " count=%d", req->count );
 462 }
 463
 464 static void dump_load_dll_request( const struct load_dll_request *req )
 465 {
 466     fprintf( stderr, " handle=%d,", req->handle );
 467     fprintf( stderr, " base=%p,", req->base );
 468     fprintf( stderr, " dbg_offset=%d,", req->dbg_offset );
 469     fprintf( stderr, " dbg_size=%d,", req->dbg_size );
 470     fprintf( stderr, " name=%p", req->name );
 471 }
 472
 473 static void dump_unload_dll_request( const struct unload_dll_request *req )
 474 {
 475     fprintf( stderr, " base=%p", req->base );
 476 }
 477
 478 static void dump_queue_apc_request( const struct queue_apc_request *req )
 479 {
 480     fprintf( stderr, " handle=%d,", req->handle );
 481     fprintf( stderr, " func=%p,", req->func );
 482     fprintf( stderr, " param=%p", req->param );
 483 }
 484
 485 static void dump_get_apc_request( const struct get_apc_request *req )
 486 {
 487 }
 488
 489 static void dump_get_apc_reply( const struct get_apc_request *req )
 490 {
 491     fprintf( stderr, " func=%p,", req->func );
 492     fprintf( stderr, " type=%d,", req->type );
 493     fprintf( stderr, " args=" );
 494     cur_pos += dump_varargs_ptrs( req );
 495 }
 496
 497 static void dump_close_handle_request( const struct close_handle_request *req )
 498 {
 499     fprintf( stderr, " handle=%d", req->handle );
 500 }
 501
 502 static void dump_get_handle_info_request( const struct get_handle_info_request *req )
 503 {
 504     fprintf( stderr, " handle=%d", req->handle );
 505 }
 506
 507 static void dump_get_handle_info_reply( const struct get_handle_info_request *req )
 508 {
 509     fprintf( stderr, " flags=%d", req->flags );
 510 }
 511
 512 static void dump_set_handle_info_request( const struct set_handle_info_request *req )
 513 {
 514     fprintf( stderr, " handle=%d,", req->handle );
 515     fprintf( stderr, " flags=%d,", req->flags );
 516     fprintf( stderr, " mask=%d", req->mask );
 517 }
 518
 519 static void dump_dup_handle_request( const struct dup_handle_request *req )
 520 {
 521     fprintf( stderr, " src_process=%d,", req->src_process );
 522     fprintf( stderr, " src_handle=%d,", req->src_handle );
 523     fprintf( stderr, " dst_process=%d,", req->dst_process );
 524     fprintf( stderr, " access=%08x,", req->access );
 525     fprintf( stderr, " inherit=%d,", req->inherit );
 526     fprintf( stderr, " options=%d", req->options );
 527 }
 528
 529 static void dump_dup_handle_reply( const struct dup_handle_request *req )
 530 {
 531     fprintf( stderr, " handle=%d", req->handle );
 532 }
 533
 534 static void dump_open_process_request( const struct open_process_request *req )
 535 {
 536     fprintf( stderr, " pid=%p,", req->pid );
 537     fprintf( stderr, " access=%08x,", req->access );
 538     fprintf( stderr, " inherit=%d", req->inherit );
 539 }
 540
 541 static void dump_open_process_reply( const struct open_process_request *req )
 542 {
 543     fprintf( stderr, " handle=%d", req->handle );
 544 }
 545
 546 static void dump_select_request( const struct select_request *req )
 547 {
 548     fprintf( stderr, " flags=%d,", req->flags );
 549     fprintf( stderr, " timeout=%d,", req->timeout );
 550     fprintf( stderr, " handles=" );
 551     cur_pos += dump_varargs_ints( req );
 552 }
 553
 554 static void dump_select_reply( const struct select_request *req )
 555 {
 556     fprintf( stderr, " signaled=%d", req->signaled );
 557 }
 558
 559 static void dump_create_event_request( const struct create_event_request *req )
 560 {
 561     fprintf( stderr, " manual_reset=%d,", req->manual_reset );
 562     fprintf( stderr, " initial_state=%d,", req->initial_state );
 563     fprintf( stderr, " inherit=%d,", req->inherit );
 564     fprintf( stderr, " name=" );
 565     cur_pos += dump_varargs_unicode_str( req );
 566 }
 567
 568 static void dump_create_event_reply( const struct create_event_request *req )
 569 {
 570     fprintf( stderr, " handle=%d", req->handle );
 571 }
 572
 573 static void dump_event_op_request( const struct event_op_request *req )
 574 {
 575     fprintf( stderr, " handle=%d,", req->handle );
 576     fprintf( stderr, " op=%d", req->op );
 577 }
 578
 579 static void dump_open_event_request( const struct open_event_request *req )
 580 {
 581     fprintf( stderr, " access=%08x,", req->access );
 582     fprintf( stderr, " inherit=%d,", req->inherit );
 583     fprintf( stderr, " name=" );
 584     cur_pos += dump_varargs_unicode_str( req );
 585 }
 586
 587 static void dump_open_event_reply( const struct open_event_request *req )
 588 {
 589     fprintf( stderr, " handle=%d", req->handle );
 590 }
 591
 592 static void dump_create_mutex_request( const struct create_mutex_request *req )
 593 {
 594     fprintf( stderr, " owned=%d,", req->owned );
 595     fprintf( stderr, " inherit=%d,", req->inherit );
 596     fprintf( stderr, " name=" );
 597     cur_pos += dump_varargs_unicode_str( req );
 598 }
 599
 600 static void dump_create_mutex_reply( const struct create_mutex_request *req )
 601 {
 602     fprintf( stderr, " handle=%d", req->handle );
 603 }
 604
 605 static void dump_release_mutex_request( const struct release_mutex_request *req )
 606 {
 607     fprintf( stderr, " handle=%d", req->handle );
 608 }
 609
 610 static void dump_open_mutex_request( const struct open_mutex_request *req )
 611 {
 612     fprintf( stderr, " access=%08x,", req->access );
 613     fprintf( stderr, " inherit=%d,", req->inherit );
 614     fprintf( stderr, " name=" );
 615     cur_pos += dump_varargs_unicode_str( req );
 616 }
 617
 618 static void dump_open_mutex_reply( const struct open_mutex_request *req )
 619 {
 620     fprintf( stderr, " handle=%d", req->handle );
 621 }
 622
 623 static void dump_create_semaphore_request( const struct create_semaphore_request *req )
 624 {
 625     fprintf( stderr, " initial=%08x,", req->initial );
 626     fprintf( stderr, " max=%08x,", req->max );
 627     fprintf( stderr, " inherit=%d,", req->inherit );
 628     fprintf( stderr, " name=" );
 629     cur_pos += dump_varargs_unicode_str( req );
 630 }
 631
 632 static void dump_create_semaphore_reply( const struct create_semaphore_request *req )
 633 {
 634     fprintf( stderr, " handle=%d", req->handle );
 635 }
 636
 637 static void dump_release_semaphore_request( const struct release_semaphore_request *req )
 638 {
 639     fprintf( stderr, " handle=%d,", req->handle );
 640     fprintf( stderr, " count=%08x", req->count );
 641 }
 642
 643 static void dump_release_semaphore_reply( const struct release_semaphore_request *req )
 644 {
 645     fprintf( stderr, " prev_count=%08x", req->prev_count );
 646 }
 647
 648 static void dump_open_semaphore_request( const struct open_semaphore_request *req )
 649 {
 650     fprintf( stderr, " access=%08x,", req->access );
 651     fprintf( stderr, " inherit=%d,", req->inherit );
 652     fprintf( stderr, " name=" );
 653     cur_pos += dump_varargs_unicode_str( req );
 654 }
 655
 656 static void dump_open_semaphore_reply( const struct open_semaphore_request *req )
 657 {
 658     fprintf( stderr, " handle=%d", req->handle );
 659 }
 660
 661 static void dump_create_file_request( const struct create_file_request *req )
 662 {
 663     fprintf( stderr, " access=%08x,", req->access );
 664     fprintf( stderr, " inherit=%d,", req->inherit );
 665     fprintf( stderr, " sharing=%08x,", req->sharing );
 666     fprintf( stderr, " create=%d,", req->create );
 667     fprintf( stderr, " attrs=%08x,", req->attrs );
 668     fprintf( stderr, " filename=" );
 669     cur_pos += dump_varargs_string( req );
 670 }
 671
 672 static void dump_create_file_reply( const struct create_file_request *req )
 673 {
 674     fprintf( stderr, " handle=%d", req->handle );
 675 }
 676
 677 static void dump_alloc_file_handle_request( const struct alloc_file_handle_request *req )
 678 {
 679     fprintf( stderr, " access=%08x", req->access );
 680 }
 681
 682 static void dump_alloc_file_handle_reply( const struct alloc_file_handle_request *req )
 683 {
 684     fprintf( stderr, " handle=%d", req->handle );
 685 }
 686
 687 static void dump_get_read_fd_request( const struct get_read_fd_request *req )
 688 {
 689     fprintf( stderr, " handle=%d", req->handle );
 690 }
 691
 692 static void dump_get_write_fd_request( const struct get_write_fd_request *req )
 693 {
 694     fprintf( stderr, " handle=%d", req->handle );
 695 }
 696
 697 static void dump_set_file_pointer_request( const struct set_file_pointer_request *req )
 698 {
 699     fprintf( stderr, " handle=%d,", req->handle );
 700     fprintf( stderr, " low=%d,", req->low );
 701     fprintf( stderr, " high=%d,", req->high );
 702     fprintf( stderr, " whence=%d", req->whence );
 703 }
 704
 705 static void dump_set_file_pointer_reply( const struct set_file_pointer_request *req )
 706 {
 707     fprintf( stderr, " new_low=%d,", req->new_low );
 708     fprintf( stderr, " new_high=%d", req->new_high );
 709 }
 710
 711 static void dump_truncate_file_request( const struct truncate_file_request *req )
 712 {
 713     fprintf( stderr, " handle=%d", req->handle );
 714 }
 715
 716 static void dump_set_file_time_request( const struct set_file_time_request *req )
 717 {
 718     fprintf( stderr, " handle=%d,", req->handle );
 719     fprintf( stderr, " access_time=%ld,", req->access_time );
 720     fprintf( stderr, " write_time=%ld", req->write_time );
 721 }
 722
 723 static void dump_flush_file_request( const struct flush_file_request *req )
 724 {
 725     fprintf( stderr, " handle=%d", req->handle );
 726 }
 727
 728 static void dump_get_file_info_request( const struct get_file_info_request *req )
 729 {
 730     fprintf( stderr, " handle=%d", req->handle );
 731 }
 732
 733 static void dump_get_file_info_reply( const struct get_file_info_request *req )
 734 {
 735     fprintf( stderr, " type=%d,", req->type );
 736     fprintf( stderr, " attr=%d,", req->attr );
 737     fprintf( stderr, " access_time=%ld,", req->access_time );
 738     fprintf( stderr, " write_time=%ld,", req->write_time );
 739     fprintf( stderr, " size_high=%d,", req->size_high );
 740     fprintf( stderr, " size_low=%d,", req->size_low );
 741     fprintf( stderr, " links=%d,", req->links );
 742     fprintf( stderr, " index_high=%d,", req->index_high );
 743     fprintf( stderr, " index_low=%d,", req->index_low );
 744     fprintf( stderr, " serial=%08x", req->serial );
 745 }
 746
 747 static void dump_lock_file_request( const struct lock_file_request *req )
 748 {
 749     fprintf( stderr, " handle=%d,", req->handle );
 750     fprintf( stderr, " offset_low=%08x,", req->offset_low );
 751     fprintf( stderr, " offset_high=%08x,", req->offset_high );
 752     fprintf( stderr, " count_low=%08x,", req->count_low );
 753     fprintf( stderr, " count_high=%08x", req->count_high );
 754 }
 755
 756 static void dump_unlock_file_request( const struct unlock_file_request *req )
 757 {
 758     fprintf( stderr, " handle=%d,", req->handle );
 759     fprintf( stderr, " offset_low=%08x,", req->offset_low );
 760     fprintf( stderr, " offset_high=%08x,", req->offset_high );
 761     fprintf( stderr, " count_low=%08x,", req->count_low );
 762     fprintf( stderr, " count_high=%08x", req->count_high );
 763 }
 764
 765 static void dump_create_pipe_request( const struct create_pipe_request *req )
 766 {
 767     fprintf( stderr, " inherit=%d", req->inherit );
 768 }
 769
 770 static void dump_create_pipe_reply( const struct create_pipe_request *req )
 771 {
 772     fprintf( stderr, " handle_read=%d,", req->handle_read );
 773     fprintf( stderr, " handle_write=%d", req->handle_write );
 774 }
 775
 776 static void dump_create_socket_request( const struct create_socket_request *req )
 777 {
 778     fprintf( stderr, " access=%08x,", req->access );
 779     fprintf( stderr, " inherit=%d,", req->inherit );
 780     fprintf( stderr, " family=%d,", req->family );
 781     fprintf( stderr, " type=%d,", req->type );
 782     fprintf( stderr, " protocol=%d", req->protocol );
 783 }
 784
 785 static void dump_create_socket_reply( const struct create_socket_request *req )
 786 {
 787     fprintf( stderr, " handle=%d", req->handle );
 788 }
 789
 790 static void dump_accept_socket_request( const struct accept_socket_request *req )
 791 {
 792     fprintf( stderr, " lhandle=%d,", req->lhandle );
 793     fprintf( stderr, " access=%08x,", req->access );
 794     fprintf( stderr, " inherit=%d", req->inherit );
 795 }
 796
 797 static void dump_accept_socket_reply( const struct accept_socket_request *req )
 798 {
 799     fprintf( stderr, " handle=%d", req->handle );
 800 }
 801
 802 static void dump_set_socket_event_request( const struct set_socket_event_request *req )
 803 {
 804     fprintf( stderr, " handle=%d,", req->handle );
 805     fprintf( stderr, " mask=%08x,", req->mask );
 806     fprintf( stderr, " event=%d", req->event );
 807 }
 808
 809 static void dump_get_socket_event_request( const struct get_socket_event_request *req )
 810 {
 811     fprintf( stderr, " handle=%d,", req->handle );
 812     fprintf( stderr, " service=%d,", req->service );
 813     fprintf( stderr, " s_event=%d,", req->s_event );
 814     fprintf( stderr, " c_event=%d", req->c_event );
 815 }
 816
 817 static void dump_get_socket_event_reply( const struct get_socket_event_request *req )
 818 {
 819     fprintf( stderr, " mask=%08x,", req->mask );
 820     fprintf( stderr, " pmask=%08x,", req->pmask );
 821     fprintf( stderr, " state=%08x,", req->state );
 822     fprintf( stderr, " errors=" );
 823     cur_pos += dump_varargs_ints( req );
 824 }
 825
 826 static void dump_enable_socket_event_request( const struct enable_socket_event_request *req )
 827 {
 828     fprintf( stderr, " handle=%d,", req->handle );
 829     fprintf( stderr, " mask=%08x,", req->mask );
 830     fprintf( stderr, " sstate=%08x,", req->sstate );
 831     fprintf( stderr, " cstate=%08x", req->cstate );
 832 }
 833
 834 static void dump_alloc_console_request( const struct alloc_console_request *req )
 835 {
 836     fprintf( stderr, " access=%08x,", req->access );
 837     fprintf( stderr, " inherit=%d", req->inherit );
 838 }
 839
 840 static void dump_alloc_console_reply( const struct alloc_console_request *req )
 841 {
 842     fprintf( stderr, " handle_in=%d,", req->handle_in );
 843     fprintf( stderr, " handle_out=%d", req->handle_out );
 844 }
 845
 846 static void dump_free_console_request( const struct free_console_request *req )
 847 {
 848 }
 849
 850 static void dump_open_console_request( const struct open_console_request *req )
 851 {
 852     fprintf( stderr, " output=%d,", req->output );
 853     fprintf( stderr, " access=%08x,", req->access );
 854     fprintf( stderr, " inherit=%d", req->inherit );
 855 }
 856
 857 static void dump_open_console_reply( const struct open_console_request *req )
 858 {
 859     fprintf( stderr, " handle=%d", req->handle );
 860 }
 861
 862 static void dump_set_console_fd_request( const struct set_console_fd_request *req )
 863 {
 864     fprintf( stderr, " handle=%d,", req->handle );
 865     fprintf( stderr, " file_handle=%d,", req->file_handle );
 866     fprintf( stderr, " pid=%d", req->pid );
 867 }
 868
 869 static void dump_get_console_mode_request( const struct get_console_mode_request *req )
 870 {
 871     fprintf( stderr, " handle=%d", req->handle );
 872 }
 873
 874 static void dump_get_console_mode_reply( const struct get_console_mode_request *req )
 875 {
 876     fprintf( stderr, " mode=%d", req->mode );
 877 }
 878
 879 static void dump_set_console_mode_request( const struct set_console_mode_request *req )
 880 {
 881     fprintf( stderr, " handle=%d,", req->handle );
 882     fprintf( stderr, " mode=%d", req->mode );
 883 }
 884
 885 static void dump_set_console_info_request( const struct set_console_info_request *req )
 886 {
 887     fprintf( stderr, " handle=%d,", req->handle );
 888     fprintf( stderr, " mask=%d,", req->mask );
 889     fprintf( stderr, " cursor_size=%d,", req->cursor_size );
 890     fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
 891     fprintf( stderr, " title=" );
 892     cur_pos += dump_varargs_string( req );
 893 }
 894
 895 static void dump_get_console_info_request( const struct get_console_info_request *req )
 896 {
 897     fprintf( stderr, " handle=%d", req->handle );
 898 }
 899
 900 static void dump_get_console_info_reply( const struct get_console_info_request *req )
 901 {
 902     fprintf( stderr, " cursor_size=%d,", req->cursor_size );
 903     fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
 904     fprintf( stderr, " pid=%d,", req->pid );
 905     fprintf( stderr, " title=" );
 906     cur_pos += dump_varargs_string( req );
 907 }
 908
 909 static void dump_write_console_input_request( const struct write_console_input_request *req )
 910 {
 911     fprintf( stderr, " handle=%d,", req->handle );
 912     fprintf( stderr, " rec=" );
 913     cur_pos += dump_varargs_input_records( req );
 914 }
 915
 916 static void dump_write_console_input_reply( const struct write_console_input_request *req )
 917 {
 918     fprintf( stderr, " written=%d", req->written );
 919 }
 920
 921 static void dump_read_console_input_request( const struct read_console_input_request *req )
 922 {
 923     fprintf( stderr, " handle=%d,", req->handle );
 924     fprintf( stderr, " flush=%d", req->flush );
 925 }
 926
 927 static void dump_read_console_input_reply( const struct read_console_input_request *req )
 928 {
 929     fprintf( stderr, " read=%d,", req->read );
 930     fprintf( stderr, " rec=" );
 931     cur_pos += dump_varargs_input_records( req );
 932 }
 933
 934 static void dump_create_change_notification_request( const struct create_change_notification_request *req )
 935 {
 936     fprintf( stderr, " subtree=%d,", req->subtree );
 937     fprintf( stderr, " filter=%d", req->filter );
 938 }
 939
 940 static void dump_create_change_notification_reply( const struct create_change_notification_request *req )
 941 {
 942     fprintf( stderr, " handle=%d", req->handle );
 943 }
 944
 945 static void dump_create_mapping_request( const struct create_mapping_request *req )
 946 {
 947     fprintf( stderr, " size_high=%d,", req->size_high );
 948     fprintf( stderr, " size_low=%d,", req->size_low );
 949     fprintf( stderr, " protect=%d,", req->protect );
 950     fprintf( stderr, " inherit=%d,", req->inherit );
 951     fprintf( stderr, " file_handle=%d,", req->file_handle );
 952     fprintf( stderr, " name=" );
 953     cur_pos += dump_varargs_unicode_str( req );
 954 }
 955
 956 static void dump_create_mapping_reply( const struct create_mapping_request *req )
 957 {
 958     fprintf( stderr, " handle=%d", req->handle );
 959 }
 960
 961 static void dump_open_mapping_request( const struct open_mapping_request *req )
 962 {
 963     fprintf( stderr, " access=%08x,", req->access );
 964     fprintf( stderr, " inherit=%d,", req->inherit );
 965     fprintf( stderr, " name=" );
 966     cur_pos += dump_varargs_unicode_str( req );
 967 }
 968
 969 static void dump_open_mapping_reply( const struct open_mapping_request *req )
 970 {
 971     fprintf( stderr, " handle=%d", req->handle );
 972 }
 973
 974 static void dump_get_mapping_info_request( const struct get_mapping_info_request *req )
 975 {
 976     fprintf( stderr, " handle=%d", req->handle );
 977 }
 978
 979 static void dump_get_mapping_info_reply( const struct get_mapping_info_request *req )
 980 {
 981     fprintf( stderr, " size_high=%d,", req->size_high );
 982     fprintf( stderr, " size_low=%d,", req->size_low );
 983     fprintf( stderr, " protect=%d,", req->protect );
 984     fprintf( stderr, " header_size=%d,", req->header_size );
 985     fprintf( stderr, " base=%p,", req->base );
 986     fprintf( stderr, " shared_file=%d,", req->shared_file );
 987     fprintf( stderr, " shared_size=%d", req->shared_size );
 988 }
 989
 990 static void dump_create_device_request( const struct create_device_request *req )
 991 {
 992     fprintf( stderr, " access=%08x,", req->access );
 993     fprintf( stderr, " inherit=%d,", req->inherit );
 994     fprintf( stderr, " id=%d", req->id );
 995 }
 996
 997 static void dump_create_device_reply( const struct create_device_request *req )
 998 {
 999     fprintf( stderr, " handle=%d", req->handle );
1000 }
1001
1002 static void dump_create_snapshot_request( const struct create_snapshot_request *req )
1003 {
1004     fprintf( stderr, " inherit=%d,", req->inherit );
1005     fprintf( stderr, " flags=%d,", req->flags );
1006     fprintf( stderr, " pid=%p", req->pid );
1007 }
1008
1009 static void dump_create_snapshot_reply( const struct create_snapshot_request *req )
1010 {
1011     fprintf( stderr, " handle=%d", req->handle );
1012 }
1013
1014 static void dump_next_process_request( const struct next_process_request *req )
1015 {
1016     fprintf( stderr, " handle=%d,", req->handle );
1017     fprintf( stderr, " reset=%d", req->reset );
1018 }
1019
1020 static void dump_next_process_reply( const struct next_process_request *req )
1021 {
1022     fprintf( stderr, " count=%d,", req->count );
1023     fprintf( stderr, " pid=%p,", req->pid );
1024     fprintf( stderr, " threads=%d,", req->threads );
1025     fprintf( stderr, " priority=%d", req->priority );
1026 }
1027
1028 static void dump_next_thread_request( const struct next_thread_request *req )
1029 {
1030     fprintf( stderr, " handle=%d,", req->handle );
1031     fprintf( stderr, " reset=%d", req->reset );
1032 }
1033
1034 static void dump_next_thread_reply( const struct next_thread_request *req )
1035 {
1036     fprintf( stderr, " count=%d,", req->count );
1037     fprintf( stderr, " pid=%p,", req->pid );
1038     fprintf( stderr, " tid=%p,", req->tid );
1039     fprintf( stderr, " base_pri=%d,", req->base_pri );
1040     fprintf( stderr, " delta_pri=%d", req->delta_pri );
1041 }
1042
1043 static void dump_next_module_request( const struct next_module_request *req )
1044 {
1045     fprintf( stderr, " handle=%d,", req->handle );
1046     fprintf( stderr, " reset=%d", req->reset );
1047 }
1048
1049 static void dump_next_module_reply( const struct next_module_request *req )
1050 {
1051     fprintf( stderr, " pid=%p,", req->pid );
1052     fprintf( stderr, " base=%p", req->base );
1053 }
1054
1055 static void dump_wait_debug_event_request( const struct wait_debug_event_request *req )
1056 {
1057     fprintf( stderr, " timeout=%d", req->timeout );
1058 }
1059
1060 static void dump_wait_debug_event_reply( const struct wait_debug_event_request *req )
1061 {
1062     fprintf( stderr, " pid=%p,", req->pid );
1063     fprintf( stderr, " tid=%p,", req->tid );
1064     fprintf( stderr, " event=" );
1065     cur_pos += dump_varargs_debug_event( req );
1066 }
1067
1068 static void dump_exception_event_request( const struct exception_event_request *req )
1069 {
1070     fprintf( stderr, " first=%d,", req->first );
1071     fprintf( stderr, " record=" );
1072     cur_pos += dump_varargs_exc_event( req );
1073 }
1074
1075 static void dump_exception_event_reply( const struct exception_event_request *req )
1076 {
1077     fprintf( stderr, " status=%d,", req->status );
1078     fprintf( stderr, " context=" );
1079     cur_pos += dump_varargs_context( req );
1080 }
1081
1082 static void dump_output_debug_string_request( const struct output_debug_string_request *req )
1083 {
1084     fprintf( stderr, " string=%p,", req->string );
1085     fprintf( stderr, " unicode=%d,", req->unicode );
1086     fprintf( stderr, " length=%d", req->length );
1087 }
1088
1089 static void dump_continue_debug_event_request( const struct continue_debug_event_request *req )
1090 {
1091     fprintf( stderr, " pid=%p,", req->pid );
1092     fprintf( stderr, " tid=%p,", req->tid );
1093     fprintf( stderr, " status=%d", req->status );
1094 }
1095
1096 static void dump_debug_process_request( const struct debug_process_request *req )
1097 {
1098     fprintf( stderr, " pid=%p", req->pid );
1099 }
1100
1101 static void dump_read_process_memory_request( const struct read_process_memory_request *req )
1102 {
1103     fprintf( stderr, " handle=%d,", req->handle );
1104     fprintf( stderr, " addr=%p,", req->addr );
1105     fprintf( stderr, " len=%d", req->len );
1106 }
1107
1108 static void dump_read_process_memory_reply( const struct read_process_memory_request *req )
1109 {
1110     fprintf( stderr, " data=" );
1111     cur_pos += dump_varargs_bytes( req );
1112 }
1113
1114 static void dump_write_process_memory_request( const struct write_process_memory_request *req )
1115 {
1116     fprintf( stderr, " handle=%d,", req->handle );
1117     fprintf( stderr, " addr=%p,", req->addr );
1118     fprintf( stderr, " len=%d,", req->len );
1119     fprintf( stderr, " first_mask=%08x,", req->first_mask );
1120     fprintf( stderr, " last_mask=%08x,", req->last_mask );
1121     fprintf( stderr, " data=" );
1122     cur_pos += dump_varargs_bytes( req );
1123 }
1124
1125 static void dump_create_key_request( const struct create_key_request *req )
1126 {
1127     fprintf( stderr, " parent=%d,", req->parent );
1128     fprintf( stderr, " access=%08x,", req->access );
1129     fprintf( stderr, " options=%08x,", req->options );
1130     fprintf( stderr, " modif=%ld,", req->modif );
1131     fprintf( stderr, " name=" );
1132     cur_pos += dump_varargs_unicode_len_str( req );
1133     fputc( ',', stderr );
1134     fprintf( stderr, " class=" );
1135     cur_pos += dump_varargs_unicode_str( req );
1136 }
1137
1138 static void dump_create_key_reply( const struct create_key_request *req )
1139 {
1140     fprintf( stderr, " hkey=%d,", req->hkey );
1141     fprintf( stderr, " created=%d", req->created );
1142 }
1143
1144 static void dump_open_key_request( const struct open_key_request *req )
1145 {
1146     fprintf( stderr, " parent=%d,", req->parent );
1147     fprintf( stderr, " access=%08x,", req->access );
1148     fprintf( stderr, " name=" );
1149     cur_pos += dump_varargs_unicode_str( req );
1150 }
1151
1152 static void dump_open_key_reply( const struct open_key_request *req )
1153 {
1154     fprintf( stderr, " hkey=%d", req->hkey );
1155 }
1156
1157 static void dump_delete_key_request( const struct delete_key_request *req )
1158 {
1159     fprintf( stderr, " hkey=%d", req->hkey );
1160 }
1161
1162 static void dump_enum_key_request( const struct enum_key_request *req )
1163 {
1164     fprintf( stderr, " hkey=%d,", req->hkey );
1165     fprintf( stderr, " index=%d,", req->index );
1166     fprintf( stderr, " full=%d", req->full );
1167 }
1168
1169 static void dump_enum_key_reply( const struct enum_key_request *req )
1170 {
1171     fprintf( stderr, " subkeys=%d,", req->subkeys );
1172     fprintf( stderr, " max_subkey=%d,", req->max_subkey );
1173     fprintf( stderr, " max_class=%d,", req->max_class );
1174     fprintf( stderr, " values=%d,", req->values );
1175     fprintf( stderr, " max_value=%d,", req->max_value );
1176     fprintf( stderr, " max_data=%d,", req->max_data );
1177     fprintf( stderr, " modif=%ld,", req->modif );
1178     fprintf( stderr, " name=" );
1179     cur_pos += dump_varargs_unicode_len_str( req );
1180     fputc( ',', stderr );
1181     fprintf( stderr, " class=" );
1182     cur_pos += dump_varargs_unicode_str( req );
1183 }
1184
1185 static void dump_set_key_value_request( const struct set_key_value_request *req )
1186 {
1187     fprintf( stderr, " hkey=%d,", req->hkey );
1188     fprintf( stderr, " type=%d,", req->type );
1189     fprintf( stderr, " total=%08x,", req->total );
1190     fprintf( stderr, " offset=%08x,", req->offset );
1191     fprintf( stderr, " name=" );
1192     cur_pos += dump_varargs_unicode_len_str( req );
1193     fputc( ',', stderr );
1194     fprintf( stderr, " data=" );
1195     cur_pos += dump_varargs_bytes( req );
1196 }
1197
1198 static void dump_get_key_value_request( const struct get_key_value_request *req )
1199 {
1200     fprintf( stderr, " hkey=%d,", req->hkey );
1201     fprintf( stderr, " offset=%08x,", req->offset );
1202     fprintf( stderr, " name=" );
1203     cur_pos += dump_varargs_unicode_len_str( req );
1204 }
1205
1206 static void dump_get_key_value_reply( const struct get_key_value_request *req )
1207 {
1208     fprintf( stderr, " type=%d,", req->type );
1209     fprintf( stderr, " len=%d,", req->len );
1210     fprintf( stderr, " data=" );
1211     cur_pos += dump_varargs_bytes( req );
1212 }
1213
1214 static void dump_enum_key_value_request( const struct enum_key_value_request *req )
1215 {
1216     fprintf( stderr, " hkey=%d,", req->hkey );
1217     fprintf( stderr, " index=%d,", req->index );
1218     fprintf( stderr, " offset=%08x", req->offset );
1219 }
1220
1221 static void dump_enum_key_value_reply( const struct enum_key_value_request *req )
1222 {
1223     fprintf( stderr, " type=%d,", req->type );
1224     fprintf( stderr, " len=%d,", req->len );
1225     fprintf( stderr, " name=" );
1226     dump_path_t( req, &req->name );
1227     fprintf( stderr, "," );
1228     fprintf( stderr, " data=" );
1229     dump_varargs_enum_key_value_reply( req );
1230 }
1231
1232 static void dump_delete_key_value_request( const struct delete_key_value_request *req )
1233 {
1234     fprintf( stderr, " hkey=%d,", req->hkey );
1235     fprintf( stderr, " name=" );
1236     cur_pos += dump_varargs_unicode_str( req );
1237 }
1238
1239 static void dump_load_registry_request( const struct load_registry_request *req )
1240 {
1241     fprintf( stderr, " hkey=%d,", req->hkey );
1242     fprintf( stderr, " file=%d,", req->file );
1243     fprintf( stderr, " name=" );
1244     cur_pos += dump_varargs_unicode_str( req );
1245 }
1246
1247 static void dump_save_registry_request( const struct save_registry_request *req )
1248 {
1249     fprintf( stderr, " hkey=%d,", req->hkey );
1250     fprintf( stderr, " file=%d", req->file );
1251 }
1252
1253 static void dump_save_registry_atexit_request( const struct save_registry_atexit_request *req )
1254 {
1255     fprintf( stderr, " hkey=%d,", req->hkey );
1256     fprintf( stderr, " file=" );
1257     cur_pos += dump_varargs_string( req );
1258 }
1259
1260 static void dump_set_registry_levels_request( const struct set_registry_levels_request *req )
1261 {
1262     fprintf( stderr, " current=%d,", req->current );
1263     fprintf( stderr, " saving=%d,", req->saving );
1264     fprintf( stderr, " period=%d", req->period );
1265 }
1266
1267 static void dump_create_timer_request( const struct create_timer_request *req )
1268 {
1269     fprintf( stderr, " inherit=%d,", req->inherit );
1270     fprintf( stderr, " manual=%d,", req->manual );
1271     fprintf( stderr, " name=" );
1272     cur_pos += dump_varargs_unicode_str( req );
1273 }
1274
1275 static void dump_create_timer_reply( const struct create_timer_request *req )
1276 {
1277     fprintf( stderr, " handle=%d", req->handle );
1278 }
1279
1280 static void dump_open_timer_request( const struct open_timer_request *req )
1281 {
1282     fprintf( stderr, " access=%08x,", req->access );
1283     fprintf( stderr, " inherit=%d,", req->inherit );
1284     fprintf( stderr, " name=" );
1285     cur_pos += dump_varargs_unicode_str( req );
1286 }
1287
1288 static void dump_open_timer_reply( const struct open_timer_request *req )
1289 {
1290     fprintf( stderr, " handle=%d", req->handle );
1291 }
1292
1293 static void dump_set_timer_request( const struct set_timer_request *req )
1294 {
1295     fprintf( stderr, " handle=%d,", req->handle );
1296     fprintf( stderr, " sec=%d,", req->sec );
1297     fprintf( stderr, " usec=%d,", req->usec );
1298     fprintf( stderr, " period=%d,", req->period );
1299     fprintf( stderr, " callback=%p,", req->callback );
1300     fprintf( stderr, " arg=%p", req->arg );
1301 }
1302
1303 static void dump_cancel_timer_request( const struct cancel_timer_request *req )
1304 {
1305     fprintf( stderr, " handle=%d", req->handle );
1306 }
1307
1308 static void dump_get_thread_context_request( const struct get_thread_context_request *req )
1309 {
1310     fprintf( stderr, " handle=%d,", req->handle );
1311     fprintf( stderr, " flags=%08x", req->flags );
1312 }
1313
1314 static void dump_get_thread_context_reply( const struct get_thread_context_request *req )
1315 {
1316     fprintf( stderr, " context=" );
1317     cur_pos += dump_varargs_context( req );
1318 }
1319
1320 static void dump_set_thread_context_request( const struct set_thread_context_request *req )
1321 {
1322     fprintf( stderr, " handle=%d,", req->handle );
1323     fprintf( stderr, " flags=%08x,", req->flags );
1324     fprintf( stderr, " context=" );
1325     cur_pos += dump_varargs_context( req );
1326 }
1327
1328 static void dump_get_selector_entry_request( const struct get_selector_entry_request *req )
1329 {
1330     fprintf( stderr, " handle=%d,", req->handle );
1331     fprintf( stderr, " entry=%d", req->entry );
1332 }
1333
1334 static void dump_get_selector_entry_reply( const struct get_selector_entry_request *req )
1335 {
1336     fprintf( stderr, " base=%08x,", req->base );
1337     fprintf( stderr, " limit=%08x,", req->limit );
1338     fprintf( stderr, " flags=%02x", req->flags );
1339 }
1340
1341 static void dump_add_atom_request( const struct add_atom_request *req )
1342 {
1343     fprintf( stderr, " local=%d,", req->local );
1344     fprintf( stderr, " name=" );
1345     cur_pos += dump_varargs_unicode_str( req );
1346 }
1347
1348 static void dump_add_atom_reply( const struct add_atom_request *req )
1349 {
1350     fprintf( stderr, " atom=%d", req->atom );
1351 }
1352
1353 static void dump_delete_atom_request( const struct delete_atom_request *req )
1354 {
1355     fprintf( stderr, " atom=%d,", req->atom );
1356     fprintf( stderr, " local=%d", req->local );
1357 }
1358
1359 static void dump_find_atom_request( const struct find_atom_request *req )
1360 {
1361     fprintf( stderr, " local=%d,", req->local );
1362     fprintf( stderr, " name=" );
1363     cur_pos += dump_varargs_unicode_str( req );
1364 }
1365
1366 static void dump_find_atom_reply( const struct find_atom_request *req )
1367 {
1368     fprintf( stderr, " atom=%d", req->atom );
1369 }
1370
1371 static void dump_get_atom_name_request( const struct get_atom_name_request *req )
1372 {
1373     fprintf( stderr, " atom=%d,", req->atom );
1374     fprintf( stderr, " local=%d", req->local );
1375 }
1376
1377 static void dump_get_atom_name_reply( const struct get_atom_name_request *req )
1378 {
1379     fprintf( stderr, " count=%d,", req->count );
1380     fprintf( stderr, " name=" );
1381     cur_pos += dump_varargs_unicode_str( req );
1382 }
1383
1384 static void dump_init_atom_table_request( const struct init_atom_table_request *req )
1385 {
1386     fprintf( stderr, " entries=%d", req->entries );
1387 }
1388
1389 static void dump_get_msg_queue_request( const struct get_msg_queue_request *req )
1390 {
1391 }
1392
1393 static void dump_get_msg_queue_reply( const struct get_msg_queue_request *req )
1394 {
1395     fprintf( stderr, " handle=%d", req->handle );
1396 }
1397
1398 static void dump_wake_queue_request( const struct wake_queue_request *req )
1399 {
1400     fprintf( stderr, " handle=%d,", req->handle );
1401     fprintf( stderr, " bits=%08x", req->bits );
1402 }
1403
1404 static void dump_wait_input_idle_request( const struct wait_input_idle_request *req )
1405 {
1406     fprintf( stderr, " handle=%d,", req->handle );
1407     fprintf( stderr, " timeout=%d", req->timeout );
1408 }
1409
1410 static void dump_wait_input_idle_reply( const struct wait_input_idle_request *req )
1411 {
1412     fprintf( stderr, " event=%d", req->event );
1413 }
1414
1415 static void dump_create_serial_request( const struct create_serial_request *req )
1416 {
1417     fprintf( stderr, " access=%08x,", req->access );
1418     fprintf( stderr, " inherit=%d,", req->inherit );
1419     fprintf( stderr, " sharing=%08x,", req->sharing );
1420     fprintf( stderr, " name=" );
1421     cur_pos += dump_varargs_string( req );
1422 }
1423
1424 static void dump_create_serial_reply( const struct create_serial_request *req )
1425 {
1426     fprintf( stderr, " handle=%d", req->handle );
1427 }
1428
1429 static void dump_get_serial_info_request( const struct get_serial_info_request *req )
1430 {
1431     fprintf( stderr, " handle=%d", req->handle );
1432 }
1433
1434 static void dump_get_serial_info_reply( const struct get_serial_info_request *req )
1435 {
1436     fprintf( stderr, " readinterval=%08x,", req->readinterval );
1437     fprintf( stderr, " readconst=%08x,", req->readconst );
1438     fprintf( stderr, " readmult=%08x,", req->readmult );
1439     fprintf( stderr, " writeconst=%08x,", req->writeconst );
1440     fprintf( stderr, " writemult=%08x,", req->writemult );
1441     fprintf( stderr, " eventmask=%08x,", req->eventmask );
1442     fprintf( stderr, " commerror=%08x", req->commerror );
1443 }
1444
1445 static void dump_set_serial_info_request( const struct set_serial_info_request *req )
1446 {
1447     fprintf( stderr, " handle=%d,", req->handle );
1448     fprintf( stderr, " flags=%d,", req->flags );
1449     fprintf( stderr, " readinterval=%08x,", req->readinterval );
1450     fprintf( stderr, " readconst=%08x,", req->readconst );
1451     fprintf( stderr, " readmult=%08x,", req->readmult );
1452     fprintf( stderr, " writeconst=%08x,", req->writeconst );
1453     fprintf( stderr, " writemult=%08x,", req->writemult );
1454     fprintf( stderr, " eventmask=%08x,", req->eventmask );
1455     fprintf( stderr, " commerror=%08x", req->commerror );
1456 }
1457
1458 static const dump_func req_dumpers[REQ_NB_REQUESTS] = {
1459     (dump_func)dump_new_process_request,
1460     (dump_func)dump_wait_process_request,
1461     (dump_func)dump_new_thread_request,
1462     (dump_func)dump_boot_done_request,
1463     (dump_func)dump_init_process_request,
1464     (dump_func)dump_init_process_done_request,
1465     (dump_func)dump_init_thread_request,
1466     (dump_func)dump_get_thread_buffer_request,
1467     (dump_func)dump_terminate_process_request,
1468     (dump_func)dump_terminate_thread_request,
1469     (dump_func)dump_get_process_info_request,
1470     (dump_func)dump_set_process_info_request,
1471     (dump_func)dump_get_thread_info_request,
1472     (dump_func)dump_set_thread_info_request,
1473     (dump_func)dump_suspend_thread_request,
1474     (dump_func)dump_resume_thread_request,
1475     (dump_func)dump_load_dll_request,
1476     (dump_func)dump_unload_dll_request,
1477     (dump_func)dump_queue_apc_request,
1478     (dump_func)dump_get_apc_request,
1479     (dump_func)dump_close_handle_request,
1480     (dump_func)dump_get_handle_info_request,
1481     (dump_func)dump_set_handle_info_request,
1482     (dump_func)dump_dup_handle_request,
1483     (dump_func)dump_open_process_request,
1484     (dump_func)dump_select_request,
1485     (dump_func)dump_create_event_request,
1486     (dump_func)dump_event_op_request,
1487     (dump_func)dump_open_event_request,
1488     (dump_func)dump_create_mutex_request,
1489     (dump_func)dump_release_mutex_request,
1490     (dump_func)dump_open_mutex_request,
1491     (dump_func)dump_create_semaphore_request,
1492     (dump_func)dump_release_semaphore_request,
1493     (dump_func)dump_open_semaphore_request,
1494     (dump_func)dump_create_file_request,
1495     (dump_func)dump_alloc_file_handle_request,
1496     (dump_func)dump_get_read_fd_request,
1497     (dump_func)dump_get_write_fd_request,
1498     (dump_func)dump_set_file_pointer_request,
1499     (dump_func)dump_truncate_file_request,
1500     (dump_func)dump_set_file_time_request,
1501     (dump_func)dump_flush_file_request,
1502     (dump_func)dump_get_file_info_request,
1503     (dump_func)dump_lock_file_request,
1504     (dump_func)dump_unlock_file_request,
1505     (dump_func)dump_create_pipe_request,
1506     (dump_func)dump_create_socket_request,
1507     (dump_func)dump_accept_socket_request,
1508     (dump_func)dump_set_socket_event_request,
1509     (dump_func)dump_get_socket_event_request,
1510     (dump_func)dump_enable_socket_event_request,
1511     (dump_func)dump_alloc_console_request,
1512     (dump_func)dump_free_console_request,
1513     (dump_func)dump_open_console_request,
1514     (dump_func)dump_set_console_fd_request,
1515     (dump_func)dump_get_console_mode_request,
1516     (dump_func)dump_set_console_mode_request,
1517     (dump_func)dump_set_console_info_request,
1518     (dump_func)dump_get_console_info_request,
1519     (dump_func)dump_write_console_input_request,
1520     (dump_func)dump_read_console_input_request,
1521     (dump_func)dump_create_change_notification_request,
1522     (dump_func)dump_create_mapping_request,
1523     (dump_func)dump_open_mapping_request,
1524     (dump_func)dump_get_mapping_info_request,
1525     (dump_func)dump_create_device_request,
1526     (dump_func)dump_create_snapshot_request,
1527     (dump_func)dump_next_process_request,
1528     (dump_func)dump_next_thread_request,
1529     (dump_func)dump_next_module_request,
1530     (dump_func)dump_wait_debug_event_request,
1531     (dump_func)dump_exception_event_request,
1532     (dump_func)dump_output_debug_string_request,
1533     (dump_func)dump_continue_debug_event_request,
1534     (dump_func)dump_debug_process_request,
1535     (dump_func)dump_read_process_memory_request,
1536     (dump_func)dump_write_process_memory_request,
1537     (dump_func)dump_create_key_request,
1538     (dump_func)dump_open_key_request,
1539     (dump_func)dump_delete_key_request,
1540     (dump_func)dump_enum_key_request,
1541     (dump_func)dump_set_key_value_request,
1542     (dump_func)dump_get_key_value_request,
1543     (dump_func)dump_enum_key_value_request,
1544     (dump_func)dump_delete_key_value_request,
1545     (dump_func)dump_load_registry_request,
1546     (dump_func)dump_save_registry_request,
1547     (dump_func)dump_save_registry_atexit_request,
1548     (dump_func)dump_set_registry_levels_request,
1549     (dump_func)dump_create_timer_request,
1550     (dump_func)dump_open_timer_request,
1551     (dump_func)dump_set_timer_request,
1552     (dump_func)dump_cancel_timer_request,
1553     (dump_func)dump_get_thread_context_request,
1554     (dump_func)dump_set_thread_context_request,
1555     (dump_func)dump_get_selector_entry_request,
1556     (dump_func)dump_add_atom_request,
1557     (dump_func)dump_delete_atom_request,
1558     (dump_func)dump_find_atom_request,
1559     (dump_func)dump_get_atom_name_request,
1560     (dump_func)dump_init_atom_table_request,
1561     (dump_func)dump_get_msg_queue_request,
1562     (dump_func)dump_wake_queue_request,
1563     (dump_func)dump_wait_input_idle_request,
1564     (dump_func)dump_create_serial_request,
1565     (dump_func)dump_get_serial_info_request,
1566     (dump_func)dump_set_serial_info_request,
1567 };
1568
1569 static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
1570     (dump_func)0,
1571     (dump_func)dump_wait_process_reply,
1572     (dump_func)dump_new_thread_reply,
1573     (dump_func)0,
1574     (dump_func)dump_init_process_reply,
1575     (dump_func)dump_init_process_done_reply,
1576     (dump_func)0,
1577     (dump_func)dump_get_thread_buffer_reply,
1578     (dump_func)dump_terminate_process_reply,
1579     (dump_func)dump_terminate_thread_reply,
1580     (dump_func)dump_get_process_info_reply,
1581     (dump_func)0,
1582     (dump_func)dump_get_thread_info_reply,
1583     (dump_func)0,
1584     (dump_func)dump_suspend_thread_reply,
1585     (dump_func)dump_resume_thread_reply,
1586     (dump_func)0,
1587     (dump_func)0,
1588     (dump_func)0,
1589     (dump_func)dump_get_apc_reply,
1590     (dump_func)0,
1591     (dump_func)dump_get_handle_info_reply,
1592     (dump_func)0,
1593     (dump_func)dump_dup_handle_reply,
1594     (dump_func)dump_open_process_reply,
1595     (dump_func)dump_select_reply,
1596     (dump_func)dump_create_event_reply,
1597     (dump_func)0,
1598     (dump_func)dump_open_event_reply,
1599     (dump_func)dump_create_mutex_reply,
1600     (dump_func)0,
1601     (dump_func)dump_open_mutex_reply,
1602     (dump_func)dump_create_semaphore_reply,
1603     (dump_func)dump_release_semaphore_reply,
1604     (dump_func)dump_open_semaphore_reply,
1605     (dump_func)dump_create_file_reply,
1606     (dump_func)dump_alloc_file_handle_reply,
1607     (dump_func)0,
1608     (dump_func)0,
1609     (dump_func)dump_set_file_pointer_reply,
1610     (dump_func)0,
1611     (dump_func)0,
1612     (dump_func)0,
1613     (dump_func)dump_get_file_info_reply,
1614     (dump_func)0,
1615     (dump_func)0,
1616     (dump_func)dump_create_pipe_reply,
1617     (dump_func)dump_create_socket_reply,
1618     (dump_func)dump_accept_socket_reply,
1619     (dump_func)0,
1620     (dump_func)dump_get_socket_event_reply,
1621     (dump_func)0,
1622     (dump_func)dump_alloc_console_reply,
1623     (dump_func)0,
1624     (dump_func)dump_open_console_reply,
1625     (dump_func)0,
1626     (dump_func)dump_get_console_mode_reply,
1627     (dump_func)0,
1628     (dump_func)0,
1629     (dump_func)dump_get_console_info_reply,
1630     (dump_func)dump_write_console_input_reply,
1631     (dump_func)dump_read_console_input_reply,
1632     (dump_func)dump_create_change_notification_reply,
1633     (dump_func)dump_create_mapping_reply,
1634     (dump_func)dump_open_mapping_reply,
1635     (dump_func)dump_get_mapping_info_reply,
1636     (dump_func)dump_create_device_reply,
1637     (dump_func)dump_create_snapshot_reply,
1638     (dump_func)dump_next_process_reply,
1639     (dump_func)dump_next_thread_reply,
1640     (dump_func)dump_next_module_reply,
1641     (dump_func)dump_wait_debug_event_reply,
1642     (dump_func)dump_exception_event_reply,
1643     (dump_func)0,
1644     (dump_func)0,
1645     (dump_func)0,
1646     (dump_func)dump_read_process_memory_reply,
1647     (dump_func)0,
1648     (dump_func)dump_create_key_reply,
1649     (dump_func)dump_open_key_reply,
1650     (dump_func)0,
1651     (dump_func)dump_enum_key_reply,
1652     (dump_func)0,
1653     (dump_func)dump_get_key_value_reply,
1654     (dump_func)dump_enum_key_value_reply,
1655     (dump_func)0,
1656     (dump_func)0,
1657     (dump_func)0,
1658     (dump_func)0,
1659     (dump_func)0,
1660     (dump_func)dump_create_timer_reply,
1661     (dump_func)dump_open_timer_reply,
1662     (dump_func)0,
1663     (dump_func)0,
1664     (dump_func)dump_get_thread_context_reply,
1665     (dump_func)0,
1666     (dump_func)dump_get_selector_entry_reply,
1667     (dump_func)dump_add_atom_reply,
1668     (dump_func)0,
1669     (dump_func)dump_find_atom_reply,
1670     (dump_func)dump_get_atom_name_reply,
1671     (dump_func)0,
1672     (dump_func)dump_get_msg_queue_reply,
1673     (dump_func)0,
1674     (dump_func)dump_wait_input_idle_reply,
1675     (dump_func)dump_create_serial_reply,
1676     (dump_func)dump_get_serial_info_reply,
1677     (dump_func)0,
1678 };
1679
1680 static const char * const req_names[REQ_NB_REQUESTS] = {
1681     "new_process",
1682     "wait_process",
1683     "new_thread",
1684     "boot_done",
1685     "init_process",
1686     "init_process_done",
1687     "init_thread",
1688     "get_thread_buffer",
1689     "terminate_process",
1690     "terminate_thread",
1691     "get_process_info",
1692     "set_process_info",
1693     "get_thread_info",
1694     "set_thread_info",
1695     "suspend_thread",
1696     "resume_thread",
1697     "load_dll",
1698     "unload_dll",
1699     "queue_apc",
1700     "get_apc",
1701     "close_handle",
1702     "get_handle_info",
1703     "set_handle_info",
1704     "dup_handle",
1705     "open_process",
1706     "select",
1707     "create_event",
1708     "event_op",
1709     "open_event",
1710     "create_mutex",
1711     "release_mutex",
1712     "open_mutex",
1713     "create_semaphore",
1714     "release_semaphore",
1715     "open_semaphore",
1716     "create_file",
1717     "alloc_file_handle",
1718     "get_read_fd",
1719     "get_write_fd",
1720     "set_file_pointer",
1721     "truncate_file",
1722     "set_file_time",
1723     "flush_file",
1724     "get_file_info",
1725     "lock_file",
1726     "unlock_file",
1727     "create_pipe",
1728     "create_socket",
1729     "accept_socket",
1730     "set_socket_event",
1731     "get_socket_event",
1732     "enable_socket_event",
1733     "alloc_console",
1734     "free_console",
1735     "open_console",
1736     "set_console_fd",
1737     "get_console_mode",
1738     "set_console_mode",
1739     "set_console_info",
1740     "get_console_info",
1741     "write_console_input",
1742     "read_console_input",
1743     "create_change_notification",
1744     "create_mapping",
1745     "open_mapping",
1746     "get_mapping_info",
1747     "create_device",
1748     "create_snapshot",
1749     "next_process",
1750     "next_thread",
1751     "next_module",
1752     "wait_debug_event",
1753     "exception_event",
1754     "output_debug_string",
1755     "continue_debug_event",
1756     "debug_process",
1757     "read_process_memory",
1758     "write_process_memory",
1759     "create_key",
1760     "open_key",
1761     "delete_key",
1762     "enum_key",
1763     "set_key_value",
1764     "get_key_value",
1765     "enum_key_value",
1766     "delete_key_value",
1767     "load_registry",
1768     "save_registry",
1769     "save_registry_atexit",
1770     "set_registry_levels",
1771     "create_timer",
1772     "open_timer",
1773     "set_timer",
1774     "cancel_timer",
1775     "get_thread_context",
1776     "set_thread_context",
1777     "get_selector_entry",
1778     "add_atom",
1779     "delete_atom",
1780     "find_atom",
1781     "get_atom_name",
1782     "init_atom_table",
1783     "get_msg_queue",
1784     "wake_queue",
1785     "wait_input_idle",
1786     "create_serial",
1787     "get_serial_info",
1788     "set_serial_info",
1789 };
1790
1791 /* ### make_requests end ### */
1792 /* Everything above this line is generated automatically by tools/make_requests */
1793
1794 void trace_request( enum request req )
1795 {
1796     cur_pos = 0;
1797     current->last_req = req;
1798     if (req < REQ_NB_REQUESTS)
1799     {
1800         fprintf( stderr, "%08x: %s(", (unsigned int)current, req_names[req] );
1801         cur_pos = 0;
1802         req_dumpers[req]( current->buffer );
1803     }
1804     else
1805         fprintf( stderr, "%08x: %d(", (unsigned int)current, req );
1806     if (current->pass_fd != -1) fprintf( stderr, " ) fd=%d\n", current->pass_fd );
1807     else fprintf( stderr, " )\n" );
1808 }
1809
1810 void trace_reply( struct thread *thread )
1811 {
1812     fprintf( stderr, "%08x: %s() = %x",
1813              (unsigned int)thread, req_names[thread->last_req], thread->error );
1814     if (reply_dumpers[thread->last_req])
1815     {
1816         fprintf( stderr, " {" );
1817         cur_pos = 0;
1818         reply_dumpers[thread->last_req]( thread->buffer );
1819         fprintf( stderr, " }" );
1820     }
1821     if (thread->pass_fd != -1) fprintf( stderr, " fd=%d\n", thread->pass_fd );
1822     else fprintf( stderr, "\n" );
1823 }