server/trace.c

   1 /*
   2  * Server request tracing
   3  *
   4  * Copyright (C) 1999 Alexandre Julliard
   5  */
   6
   7 #include <stdio.h>
   8 #include <sys/types.h>
   9 #include <sys/uio.h>
  10 #include "winsock2.h"
  11 #include "request.h"
  12
  13
  14 /* dumping for functions for requests that have a variable part */
  15
  16 static void dump_varargs_select( struct select_request *req )
  17 {
  18     int i;
  19     for (i = 0; i < req->count; i++)
  20         fprintf( stderr, "%c%d", i ? ',' : '{', req->handles[i] );
  21     fprintf( stderr, "}" );
  22 }
  23
  24 static void dump_varargs_get_apcs( struct get_apcs_request *req )
  25 {
  26     int i;
  27     for (i = 0; i < 2 * req->count; i++)
  28         fprintf( stderr, "%c%p", i ? ',' : '{', req->apcs[i] );
  29     fprintf( stderr, "}" );
  30 }
  31
  32 static void dump_varargs_get_socket_event( struct get_socket_event_request *req )
  33 {
  34     int i;
  35     for (i = 0; i < FD_MAX_EVENTS; i++)
  36         fprintf( stderr, "%c%d", i ? ',' : '{', req->errors[i] );
  37     fprintf( stderr, "}" );
  38 }
  39
  40
  41 typedef void (*dump_func)( const void *req );
  42
  43 /* Everything below this line is generated automatically by tools/make_requests */
  44 /* ### make_requests begin ### */
  45
  46 static void dump_new_process_request( struct new_process_request *req )
  47 {
  48     fprintf( stderr, " inherit=%d,", req->inherit );
  49     fprintf( stderr, " inherit_all=%d,", req->inherit_all );
  50     fprintf( stderr, " create_flags=%d,", req->create_flags );
  51     fprintf( stderr, " start_flags=%d,", req->start_flags );
  52     fprintf( stderr, " hstdin=%d,", req->hstdin );
  53     fprintf( stderr, " hstdout=%d,", req->hstdout );
  54     fprintf( stderr, " hstderr=%d,", req->hstderr );
  55     fprintf( stderr, " event=%d,", req->event );
  56     fprintf( stderr, " cmd_show=%d,", req->cmd_show );
  57     fprintf( stderr, " env_ptr=%p,", req->env_ptr );
  58     fprintf( stderr, " cmdline=\"%s\"", req->cmdline );
  59 }
  60
  61 static void dump_new_process_reply( struct new_process_request *req )
  62 {
  63     fprintf( stderr, " pid=%p,", req->pid );
  64     fprintf( stderr, " handle=%d", req->handle );
  65 }
  66
  67 static void dump_new_thread_request( struct new_thread_request *req )
  68 {
  69     fprintf( stderr, " pid=%p,", req->pid );
  70     fprintf( stderr, " suspend=%d,", req->suspend );
  71     fprintf( stderr, " inherit=%d", req->inherit );
  72 }
  73
  74 static void dump_new_thread_reply( struct new_thread_request *req )
  75 {
  76     fprintf( stderr, " tid=%p,", req->tid );
  77     fprintf( stderr, " handle=%d", req->handle );
  78 }
  79
  80 static void dump_set_debug_request( struct set_debug_request *req )
  81 {
  82     fprintf( stderr, " level=%d", req->level );
  83 }
  84
  85 static void dump_init_process_request( struct init_process_request *req )
  86 {
  87 }
  88
  89 static void dump_init_process_reply( struct init_process_request *req )
  90 {
  91     fprintf( stderr, " start_flags=%d,", req->start_flags );
  92     fprintf( stderr, " hstdin=%d,", req->hstdin );
  93     fprintf( stderr, " hstdout=%d,", req->hstdout );
  94     fprintf( stderr, " hstderr=%d,", req->hstderr );
  95     fprintf( stderr, " cmd_show=%d,", req->cmd_show );
  96     fprintf( stderr, " env_ptr=%p,", req->env_ptr );
  97     fprintf( stderr, " cmdline=\"%s\"", req->cmdline );
  98 }
  99
 100 static void dump_init_process_done_request( struct init_process_done_request *req )
 101 {
 102     fprintf( stderr, " dummy=%d", req->dummy );
 103 }
 104
 105 static void dump_init_thread_request( struct init_thread_request *req )
 106 {
 107     fprintf( stderr, " unix_pid=%d,", req->unix_pid );
 108     fprintf( stderr, " teb=%p", req->teb );
 109 }
 110
 111 static void dump_init_thread_reply( struct init_thread_request *req )
 112 {
 113     fprintf( stderr, " pid=%p,", req->pid );
 114     fprintf( stderr, " tid=%p", req->tid );
 115 }
 116
 117 static void dump_get_thread_buffer_request( struct get_thread_buffer_request *req )
 118 {
 119     fprintf( stderr, " dummy=%d", req->dummy );
 120 }
 121
 122 static void dump_terminate_process_request( struct terminate_process_request *req )
 123 {
 124     fprintf( stderr, " handle=%d,", req->handle );
 125     fprintf( stderr, " exit_code=%d", req->exit_code );
 126 }
 127
 128 static void dump_terminate_thread_request( struct terminate_thread_request *req )
 129 {
 130     fprintf( stderr, " handle=%d,", req->handle );
 131     fprintf( stderr, " exit_code=%d", req->exit_code );
 132 }
 133
 134 static void dump_get_process_info_request( struct get_process_info_request *req )
 135 {
 136     fprintf( stderr, " handle=%d", req->handle );
 137 }
 138
 139 static void dump_get_process_info_reply( struct get_process_info_request *req )
 140 {
 141     fprintf( stderr, " pid=%p,", req->pid );
 142     fprintf( stderr, " exit_code=%d,", req->exit_code );
 143     fprintf( stderr, " priority=%d,", req->priority );
 144     fprintf( stderr, " process_affinity=%d,", req->process_affinity );
 145     fprintf( stderr, " system_affinity=%d", req->system_affinity );
 146 }
 147
 148 static void dump_set_process_info_request( struct set_process_info_request *req )
 149 {
 150     fprintf( stderr, " handle=%d,", req->handle );
 151     fprintf( stderr, " mask=%d,", req->mask );
 152     fprintf( stderr, " priority=%d,", req->priority );
 153     fprintf( stderr, " affinity=%d", req->affinity );
 154 }
 155
 156 static void dump_get_thread_info_request( struct get_thread_info_request *req )
 157 {
 158     fprintf( stderr, " handle=%d", req->handle );
 159 }
 160
 161 static void dump_get_thread_info_reply( struct get_thread_info_request *req )
 162 {
 163     fprintf( stderr, " tid=%p,", req->tid );
 164     fprintf( stderr, " exit_code=%d,", req->exit_code );
 165     fprintf( stderr, " priority=%d", req->priority );
 166 }
 167
 168 static void dump_set_thread_info_request( struct set_thread_info_request *req )
 169 {
 170     fprintf( stderr, " handle=%d,", req->handle );
 171     fprintf( stderr, " mask=%d,", req->mask );
 172     fprintf( stderr, " priority=%d,", req->priority );
 173     fprintf( stderr, " affinity=%d", req->affinity );
 174 }
 175
 176 static void dump_suspend_thread_request( struct suspend_thread_request *req )
 177 {
 178     fprintf( stderr, " handle=%d", req->handle );
 179 }
 180
 181 static void dump_suspend_thread_reply( struct suspend_thread_request *req )
 182 {
 183     fprintf( stderr, " count=%d", req->count );
 184 }
 185
 186 static void dump_resume_thread_request( struct resume_thread_request *req )
 187 {
 188     fprintf( stderr, " handle=%d", req->handle );
 189 }
 190
 191 static void dump_resume_thread_reply( struct resume_thread_request *req )
 192 {
 193     fprintf( stderr, " count=%d", req->count );
 194 }
 195
 196 static void dump_debugger_request( struct debugger_request *req )
 197 {
 198     fprintf( stderr, " op=%d", req->op );
 199 }
 200
 201 static void dump_queue_apc_request( struct queue_apc_request *req )
 202 {
 203     fprintf( stderr, " handle=%d,", req->handle );
 204     fprintf( stderr, " func=%p,", req->func );
 205     fprintf( stderr, " param=%p", req->param );
 206 }
 207
 208 static void dump_get_apcs_request( struct get_apcs_request *req )
 209 {
 210 }
 211
 212 static void dump_get_apcs_reply( struct get_apcs_request *req )
 213 {
 214     fprintf( stderr, " count=%d,", req->count );
 215     fprintf( stderr, " apcs=" );
 216     dump_varargs_get_apcs( req );
 217 }
 218
 219 static void dump_close_handle_request( struct close_handle_request *req )
 220 {
 221     fprintf( stderr, " handle=%d", req->handle );
 222 }
 223
 224 static void dump_get_handle_info_request( struct get_handle_info_request *req )
 225 {
 226     fprintf( stderr, " handle=%d", req->handle );
 227 }
 228
 229 static void dump_get_handle_info_reply( struct get_handle_info_request *req )
 230 {
 231     fprintf( stderr, " flags=%d", req->flags );
 232 }
 233
 234 static void dump_set_handle_info_request( struct set_handle_info_request *req )
 235 {
 236     fprintf( stderr, " handle=%d,", req->handle );
 237     fprintf( stderr, " flags=%d,", req->flags );
 238     fprintf( stderr, " mask=%d", req->mask );
 239 }
 240
 241 static void dump_dup_handle_request( struct dup_handle_request *req )
 242 {
 243     fprintf( stderr, " src_process=%d,", req->src_process );
 244     fprintf( stderr, " src_handle=%d,", req->src_handle );
 245     fprintf( stderr, " dst_process=%d,", req->dst_process );
 246     fprintf( stderr, " access=%08x,", req->access );
 247     fprintf( stderr, " inherit=%d,", req->inherit );
 248     fprintf( stderr, " options=%d", req->options );
 249 }
 250
 251 static void dump_dup_handle_reply( struct dup_handle_request *req )
 252 {
 253     fprintf( stderr, " handle=%d", req->handle );
 254 }
 255
 256 static void dump_open_process_request( struct open_process_request *req )
 257 {
 258     fprintf( stderr, " pid=%p,", req->pid );
 259     fprintf( stderr, " access=%08x,", req->access );
 260     fprintf( stderr, " inherit=%d", req->inherit );
 261 }
 262
 263 static void dump_open_process_reply( struct open_process_request *req )
 264 {
 265     fprintf( stderr, " handle=%d", req->handle );
 266 }
 267
 268 static void dump_select_request( struct select_request *req )
 269 {
 270     fprintf( stderr, " count=%d,", req->count );
 271     fprintf( stderr, " flags=%d,", req->flags );
 272     fprintf( stderr, " timeout=%d,", req->timeout );
 273     fprintf( stderr, " handles=" );
 274     dump_varargs_select( req );
 275 }
 276
 277 static void dump_select_reply( struct select_request *req )
 278 {
 279     fprintf( stderr, " signaled=%d", req->signaled );
 280 }
 281
 282 static void dump_create_event_request( struct create_event_request *req )
 283 {
 284     fprintf( stderr, " manual_reset=%d,", req->manual_reset );
 285     fprintf( stderr, " initial_state=%d,", req->initial_state );
 286     fprintf( stderr, " inherit=%d,", req->inherit );
 287     fprintf( stderr, " name=\"%s\"", req->name );
 288 }
 289
 290 static void dump_create_event_reply( struct create_event_request *req )
 291 {
 292     fprintf( stderr, " handle=%d", req->handle );
 293 }
 294
 295 static void dump_event_op_request( struct event_op_request *req )
 296 {
 297     fprintf( stderr, " handle=%d,", req->handle );
 298     fprintf( stderr, " op=%d", req->op );
 299 }
 300
 301 static void dump_open_event_request( struct open_event_request *req )
 302 {
 303     fprintf( stderr, " access=%08x,", req->access );
 304     fprintf( stderr, " inherit=%d,", req->inherit );
 305     fprintf( stderr, " name=\"%s\"", req->name );
 306 }
 307
 308 static void dump_open_event_reply( struct open_event_request *req )
 309 {
 310     fprintf( stderr, " handle=%d", req->handle );
 311 }
 312
 313 static void dump_create_mutex_request( struct create_mutex_request *req )
 314 {
 315     fprintf( stderr, " owned=%d,", req->owned );
 316     fprintf( stderr, " inherit=%d,", req->inherit );
 317     fprintf( stderr, " name=\"%s\"", req->name );
 318 }
 319
 320 static void dump_create_mutex_reply( struct create_mutex_request *req )
 321 {
 322     fprintf( stderr, " handle=%d", req->handle );
 323 }
 324
 325 static void dump_release_mutex_request( struct release_mutex_request *req )
 326 {
 327     fprintf( stderr, " handle=%d", req->handle );
 328 }
 329
 330 static void dump_open_mutex_request( struct open_mutex_request *req )
 331 {
 332     fprintf( stderr, " access=%08x,", req->access );
 333     fprintf( stderr, " inherit=%d,", req->inherit );
 334     fprintf( stderr, " name=\"%s\"", req->name );
 335 }
 336
 337 static void dump_open_mutex_reply( struct open_mutex_request *req )
 338 {
 339     fprintf( stderr, " handle=%d", req->handle );
 340 }
 341
 342 static void dump_create_semaphore_request( struct create_semaphore_request *req )
 343 {
 344     fprintf( stderr, " initial=%08x,", req->initial );
 345     fprintf( stderr, " max=%08x,", req->max );
 346     fprintf( stderr, " inherit=%d,", req->inherit );
 347     fprintf( stderr, " name=\"%s\"", req->name );
 348 }
 349
 350 static void dump_create_semaphore_reply( struct create_semaphore_request *req )
 351 {
 352     fprintf( stderr, " handle=%d", req->handle );
 353 }
 354
 355 static void dump_release_semaphore_request( struct release_semaphore_request *req )
 356 {
 357     fprintf( stderr, " handle=%d,", req->handle );
 358     fprintf( stderr, " count=%08x", req->count );
 359 }
 360
 361 static void dump_release_semaphore_reply( struct release_semaphore_request *req )
 362 {
 363     fprintf( stderr, " prev_count=%08x", req->prev_count );
 364 }
 365
 366 static void dump_open_semaphore_request( struct open_semaphore_request *req )
 367 {
 368     fprintf( stderr, " access=%08x,", req->access );
 369     fprintf( stderr, " inherit=%d,", req->inherit );
 370     fprintf( stderr, " name=\"%s\"", req->name );
 371 }
 372
 373 static void dump_open_semaphore_reply( struct open_semaphore_request *req )
 374 {
 375     fprintf( stderr, " handle=%d", req->handle );
 376 }
 377
 378 static void dump_create_file_request( struct create_file_request *req )
 379 {
 380     fprintf( stderr, " access=%08x,", req->access );
 381     fprintf( stderr, " inherit=%d,", req->inherit );
 382     fprintf( stderr, " sharing=%08x,", req->sharing );
 383     fprintf( stderr, " create=%d,", req->create );
 384     fprintf( stderr, " attrs=%08x,", req->attrs );
 385     fprintf( stderr, " name=\"%s\"", req->name );
 386 }
 387
 388 static void dump_create_file_reply( struct create_file_request *req )
 389 {
 390     fprintf( stderr, " handle=%d", req->handle );
 391 }
 392
 393 static void dump_alloc_file_handle_request( struct alloc_file_handle_request *req )
 394 {
 395     fprintf( stderr, " access=%08x", req->access );
 396 }
 397
 398 static void dump_alloc_file_handle_reply( struct alloc_file_handle_request *req )
 399 {
 400     fprintf( stderr, " handle=%d", req->handle );
 401 }
 402
 403 static void dump_get_read_fd_request( struct get_read_fd_request *req )
 404 {
 405     fprintf( stderr, " handle=%d", req->handle );
 406 }
 407
 408 static void dump_get_write_fd_request( struct get_write_fd_request *req )
 409 {
 410     fprintf( stderr, " handle=%d", req->handle );
 411 }
 412
 413 static void dump_set_file_pointer_request( struct set_file_pointer_request *req )
 414 {
 415     fprintf( stderr, " handle=%d,", req->handle );
 416     fprintf( stderr, " low=%d,", req->low );
 417     fprintf( stderr, " high=%d,", req->high );
 418     fprintf( stderr, " whence=%d", req->whence );
 419 }
 420
 421 static void dump_set_file_pointer_reply( struct set_file_pointer_request *req )
 422 {
 423     fprintf( stderr, " new_low=%d,", req->new_low );
 424     fprintf( stderr, " new_high=%d", req->new_high );
 425 }
 426
 427 static void dump_truncate_file_request( struct truncate_file_request *req )
 428 {
 429     fprintf( stderr, " handle=%d", req->handle );
 430 }
 431
 432 static void dump_set_file_time_request( struct set_file_time_request *req )
 433 {
 434     fprintf( stderr, " handle=%d,", req->handle );
 435     fprintf( stderr, " access_time=%ld,", req->access_time );
 436     fprintf( stderr, " write_time=%ld", req->write_time );
 437 }
 438
 439 static void dump_flush_file_request( struct flush_file_request *req )
 440 {
 441     fprintf( stderr, " handle=%d", req->handle );
 442 }
 443
 444 static void dump_get_file_info_request( struct get_file_info_request *req )
 445 {
 446     fprintf( stderr, " handle=%d", req->handle );
 447 }
 448
 449 static void dump_get_file_info_reply( struct get_file_info_request *req )
 450 {
 451     fprintf( stderr, " type=%d,", req->type );
 452     fprintf( stderr, " attr=%d,", req->attr );
 453     fprintf( stderr, " access_time=%ld,", req->access_time );
 454     fprintf( stderr, " write_time=%ld,", req->write_time );
 455     fprintf( stderr, " size_high=%d,", req->size_high );
 456     fprintf( stderr, " size_low=%d,", req->size_low );
 457     fprintf( stderr, " links=%d,", req->links );
 458     fprintf( stderr, " index_high=%d,", req->index_high );
 459     fprintf( stderr, " index_low=%d,", req->index_low );
 460     fprintf( stderr, " serial=%08x", req->serial );
 461 }
 462
 463 static void dump_lock_file_request( struct lock_file_request *req )
 464 {
 465     fprintf( stderr, " handle=%d,", req->handle );
 466     fprintf( stderr, " offset_low=%08x,", req->offset_low );
 467     fprintf( stderr, " offset_high=%08x,", req->offset_high );
 468     fprintf( stderr, " count_low=%08x,", req->count_low );
 469     fprintf( stderr, " count_high=%08x", req->count_high );
 470 }
 471
 472 static void dump_unlock_file_request( struct unlock_file_request *req )
 473 {
 474     fprintf( stderr, " handle=%d,", req->handle );
 475     fprintf( stderr, " offset_low=%08x,", req->offset_low );
 476     fprintf( stderr, " offset_high=%08x,", req->offset_high );
 477     fprintf( stderr, " count_low=%08x,", req->count_low );
 478     fprintf( stderr, " count_high=%08x", req->count_high );
 479 }
 480
 481 static void dump_create_pipe_request( struct create_pipe_request *req )
 482 {
 483     fprintf( stderr, " inherit=%d", req->inherit );
 484 }
 485
 486 static void dump_create_pipe_reply( struct create_pipe_request *req )
 487 {
 488     fprintf( stderr, " handle_read=%d,", req->handle_read );
 489     fprintf( stderr, " handle_write=%d", req->handle_write );
 490 }
 491
 492 static void dump_create_socket_request( struct create_socket_request *req )
 493 {
 494     fprintf( stderr, " access=%08x,", req->access );
 495     fprintf( stderr, " inherit=%d,", req->inherit );
 496     fprintf( stderr, " family=%d,", req->family );
 497     fprintf( stderr, " type=%d,", req->type );
 498     fprintf( stderr, " protocol=%d", req->protocol );
 499 }
 500
 501 static void dump_create_socket_reply( struct create_socket_request *req )
 502 {
 503     fprintf( stderr, " handle=%d", req->handle );
 504 }
 505
 506 static void dump_accept_socket_request( struct accept_socket_request *req )
 507 {
 508     fprintf( stderr, " lhandle=%d,", req->lhandle );
 509     fprintf( stderr, " access=%08x,", req->access );
 510     fprintf( stderr, " inherit=%d", req->inherit );
 511 }
 512
 513 static void dump_accept_socket_reply( struct accept_socket_request *req )
 514 {
 515     fprintf( stderr, " handle=%d", req->handle );
 516 }
 517
 518 static void dump_set_socket_event_request( struct set_socket_event_request *req )
 519 {
 520     fprintf( stderr, " handle=%d,", req->handle );
 521     fprintf( stderr, " mask=%08x,", req->mask );
 522     fprintf( stderr, " event=%d", req->event );
 523 }
 524
 525 static void dump_get_socket_event_request( struct get_socket_event_request *req )
 526 {
 527     fprintf( stderr, " handle=%d,", req->handle );
 528     fprintf( stderr, " service=%d,", req->service );
 529     fprintf( stderr, " s_event=%d", req->s_event );
 530 }
 531
 532 static void dump_get_socket_event_reply( struct get_socket_event_request *req )
 533 {
 534     fprintf( stderr, " mask=%08x,", req->mask );
 535     fprintf( stderr, " pmask=%08x,", req->pmask );
 536     fprintf( stderr, " state=%08x,", req->state );
 537     fprintf( stderr, " errors=" );
 538     dump_varargs_get_socket_event( req );
 539 }
 540
 541 static void dump_enable_socket_event_request( struct enable_socket_event_request *req )
 542 {
 543     fprintf( stderr, " handle=%d,", req->handle );
 544     fprintf( stderr, " mask=%08x,", req->mask );
 545     fprintf( stderr, " sstate=%08x,", req->sstate );
 546     fprintf( stderr, " cstate=%08x", req->cstate );
 547 }
 548
 549 static void dump_alloc_console_request( struct alloc_console_request *req )
 550 {
 551     fprintf( stderr, " access=%08x,", req->access );
 552     fprintf( stderr, " inherit=%d", req->inherit );
 553 }
 554
 555 static void dump_alloc_console_reply( struct alloc_console_request *req )
 556 {
 557     fprintf( stderr, " handle_in=%d,", req->handle_in );
 558     fprintf( stderr, " handle_out=%d", req->handle_out );
 559 }
 560
 561 static void dump_free_console_request( struct free_console_request *req )
 562 {
 563     fprintf( stderr, " dummy=%d", req->dummy );
 564 }
 565
 566 static void dump_open_console_request( struct open_console_request *req )
 567 {
 568     fprintf( stderr, " output=%d,", req->output );
 569     fprintf( stderr, " access=%08x,", req->access );
 570     fprintf( stderr, " inherit=%d", req->inherit );
 571 }
 572
 573 static void dump_open_console_reply( struct open_console_request *req )
 574 {
 575     fprintf( stderr, " handle=%d", req->handle );
 576 }
 577
 578 static void dump_set_console_fd_request( struct set_console_fd_request *req )
 579 {
 580     fprintf( stderr, " handle=%d,", req->handle );
 581     fprintf( stderr, " file_handle=%d,", req->file_handle );
 582     fprintf( stderr, " pid=%d", req->pid );
 583 }
 584
 585 static void dump_get_console_mode_request( struct get_console_mode_request *req )
 586 {
 587     fprintf( stderr, " handle=%d", req->handle );
 588 }
 589
 590 static void dump_get_console_mode_reply( struct get_console_mode_request *req )
 591 {
 592     fprintf( stderr, " mode=%d", req->mode );
 593 }
 594
 595 static void dump_set_console_mode_request( struct set_console_mode_request *req )
 596 {
 597     fprintf( stderr, " handle=%d,", req->handle );
 598     fprintf( stderr, " mode=%d", req->mode );
 599 }
 600
 601 static void dump_set_console_info_request( struct set_console_info_request *req )
 602 {
 603     fprintf( stderr, " handle=%d,", req->handle );
 604     fprintf( stderr, " mask=%d,", req->mask );
 605     fprintf( stderr, " cursor_size=%d,", req->cursor_size );
 606     fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
 607     fprintf( stderr, " title=\"%s\"", req->title );
 608 }
 609
 610 static void dump_get_console_info_request( struct get_console_info_request *req )
 611 {
 612     fprintf( stderr, " handle=%d", req->handle );
 613 }
 614
 615 static void dump_get_console_info_reply( struct get_console_info_request *req )
 616 {
 617     fprintf( stderr, " cursor_size=%d,", req->cursor_size );
 618     fprintf( stderr, " cursor_visible=%d,", req->cursor_visible );
 619     fprintf( stderr, " pid=%d,", req->pid );
 620     fprintf( stderr, " title=\"%s\"", req->title );
 621 }
 622
 623 static void dump_write_console_input_request( struct write_console_input_request *req )
 624 {
 625     fprintf( stderr, " handle=%d,", req->handle );
 626     fprintf( stderr, " count=%d", req->count );
 627 }
 628
 629 static void dump_write_console_input_reply( struct write_console_input_request *req )
 630 {
 631     fprintf( stderr, " written=%d", req->written );
 632 }
 633
 634 static void dump_read_console_input_request( struct read_console_input_request *req )
 635 {
 636     fprintf( stderr, " handle=%d,", req->handle );
 637     fprintf( stderr, " count=%d,", req->count );
 638     fprintf( stderr, " flush=%d", req->flush );
 639 }
 640
 641 static void dump_read_console_input_reply( struct read_console_input_request *req )
 642 {
 643     fprintf( stderr, " read=%d", req->read );
 644 }
 645
 646 static void dump_create_change_notification_request( struct create_change_notification_request *req )
 647 {
 648     fprintf( stderr, " subtree=%d,", req->subtree );
 649     fprintf( stderr, " filter=%d", req->filter );
 650 }
 651
 652 static void dump_create_change_notification_reply( struct create_change_notification_request *req )
 653 {
 654     fprintf( stderr, " handle=%d", req->handle );
 655 }
 656
 657 static void dump_create_mapping_request( struct create_mapping_request *req )
 658 {
 659     fprintf( stderr, " size_high=%d,", req->size_high );
 660     fprintf( stderr, " size_low=%d,", req->size_low );
 661     fprintf( stderr, " protect=%d,", req->protect );
 662     fprintf( stderr, " inherit=%d,", req->inherit );
 663     fprintf( stderr, " file_handle=%d,", req->file_handle );
 664     fprintf( stderr, " name=\"%s\"", req->name );
 665 }
 666
 667 static void dump_create_mapping_reply( struct create_mapping_request *req )
 668 {
 669     fprintf( stderr, " handle=%d", req->handle );
 670 }
 671
 672 static void dump_open_mapping_request( struct open_mapping_request *req )
 673 {
 674     fprintf( stderr, " access=%08x,", req->access );
 675     fprintf( stderr, " inherit=%d,", req->inherit );
 676     fprintf( stderr, " name=\"%s\"", req->name );
 677 }
 678
 679 static void dump_open_mapping_reply( struct open_mapping_request *req )
 680 {
 681     fprintf( stderr, " handle=%d", req->handle );
 682 }
 683
 684 static void dump_get_mapping_info_request( struct get_mapping_info_request *req )
 685 {
 686     fprintf( stderr, " handle=%d", req->handle );
 687 }
 688
 689 static void dump_get_mapping_info_reply( struct get_mapping_info_request *req )
 690 {
 691     fprintf( stderr, " size_high=%d,", req->size_high );
 692     fprintf( stderr, " size_low=%d,", req->size_low );
 693     fprintf( stderr, " protect=%d", req->protect );
 694 }
 695
 696 static void dump_create_device_request( struct create_device_request *req )
 697 {
 698     fprintf( stderr, " access=%08x,", req->access );
 699     fprintf( stderr, " inherit=%d,", req->inherit );
 700     fprintf( stderr, " id=%d", req->id );
 701 }
 702
 703 static void dump_create_device_reply( struct create_device_request *req )
 704 {
 705     fprintf( stderr, " handle=%d", req->handle );
 706 }
 707
 708 static void dump_create_snapshot_request( struct create_snapshot_request *req )
 709 {
 710     fprintf( stderr, " inherit=%d,", req->inherit );
 711     fprintf( stderr, " flags=%d", req->flags );
 712 }
 713
 714 static void dump_create_snapshot_reply( struct create_snapshot_request *req )
 715 {
 716     fprintf( stderr, " handle=%d", req->handle );
 717 }
 718
 719 static void dump_next_process_request( struct next_process_request *req )
 720 {
 721     fprintf( stderr, " handle=%d,", req->handle );
 722     fprintf( stderr, " reset=%d", req->reset );
 723 }
 724
 725 static void dump_next_process_reply( struct next_process_request *req )
 726 {
 727     fprintf( stderr, " pid=%p,", req->pid );
 728     fprintf( stderr, " threads=%d,", req->threads );
 729     fprintf( stderr, " priority=%d", req->priority );
 730 }
 731
 732 static void dump_wait_debug_event_request( struct wait_debug_event_request *req )
 733 {
 734     fprintf( stderr, " timeout=%d", req->timeout );
 735 }
 736
 737 static void dump_wait_debug_event_reply( struct wait_debug_event_request *req )
 738 {
 739     fprintf( stderr, " code=%d,", req->code );
 740     fprintf( stderr, " pid=%p,", req->pid );
 741     fprintf( stderr, " tid=%p", req->tid );
 742 }
 743
 744 static void dump_send_debug_event_request( struct send_debug_event_request *req )
 745 {
 746     fprintf( stderr, " code=%d", req->code );
 747 }
 748
 749 static void dump_send_debug_event_reply( struct send_debug_event_request *req )
 750 {
 751     fprintf( stderr, " status=%d", req->status );
 752 }
 753
 754 static void dump_continue_debug_event_request( struct continue_debug_event_request *req )
 755 {
 756     fprintf( stderr, " pid=%p,", req->pid );
 757     fprintf( stderr, " tid=%p,", req->tid );
 758     fprintf( stderr, " status=%d", req->status );
 759 }
 760
 761 static void dump_debug_process_request( struct debug_process_request *req )
 762 {
 763     fprintf( stderr, " pid=%p", req->pid );
 764 }
 765
 766 static const dump_func req_dumpers[REQ_NB_REQUESTS] = {
 767     (dump_func)dump_new_process_request,
 768     (dump_func)dump_new_thread_request,
 769     (dump_func)dump_set_debug_request,
 770     (dump_func)dump_init_process_request,
 771     (dump_func)dump_init_process_done_request,
 772     (dump_func)dump_init_thread_request,
 773     (dump_func)dump_get_thread_buffer_request,
 774     (dump_func)dump_terminate_process_request,
 775     (dump_func)dump_terminate_thread_request,
 776     (dump_func)dump_get_process_info_request,
 777     (dump_func)dump_set_process_info_request,
 778     (dump_func)dump_get_thread_info_request,
 779     (dump_func)dump_set_thread_info_request,
 780     (dump_func)dump_suspend_thread_request,
 781     (dump_func)dump_resume_thread_request,
 782     (dump_func)dump_debugger_request,
 783     (dump_func)dump_queue_apc_request,
 784     (dump_func)dump_get_apcs_request,
 785     (dump_func)dump_close_handle_request,
 786     (dump_func)dump_get_handle_info_request,
 787     (dump_func)dump_set_handle_info_request,
 788     (dump_func)dump_dup_handle_request,
 789     (dump_func)dump_open_process_request,
 790     (dump_func)dump_select_request,
 791     (dump_func)dump_create_event_request,
 792     (dump_func)dump_event_op_request,
 793     (dump_func)dump_open_event_request,
 794     (dump_func)dump_create_mutex_request,
 795     (dump_func)dump_release_mutex_request,
 796     (dump_func)dump_open_mutex_request,
 797     (dump_func)dump_create_semaphore_request,
 798     (dump_func)dump_release_semaphore_request,
 799     (dump_func)dump_open_semaphore_request,
 800     (dump_func)dump_create_file_request,
 801     (dump_func)dump_alloc_file_handle_request,
 802     (dump_func)dump_get_read_fd_request,
 803     (dump_func)dump_get_write_fd_request,
 804     (dump_func)dump_set_file_pointer_request,
 805     (dump_func)dump_truncate_file_request,
 806     (dump_func)dump_set_file_time_request,
 807     (dump_func)dump_flush_file_request,
 808     (dump_func)dump_get_file_info_request,
 809     (dump_func)dump_lock_file_request,
 810     (dump_func)dump_unlock_file_request,
 811     (dump_func)dump_create_pipe_request,
 812     (dump_func)dump_create_socket_request,
 813     (dump_func)dump_accept_socket_request,
 814     (dump_func)dump_set_socket_event_request,
 815     (dump_func)dump_get_socket_event_request,
 816     (dump_func)dump_enable_socket_event_request,
 817     (dump_func)dump_alloc_console_request,
 818     (dump_func)dump_free_console_request,
 819     (dump_func)dump_open_console_request,
 820     (dump_func)dump_set_console_fd_request,
 821     (dump_func)dump_get_console_mode_request,
 822     (dump_func)dump_set_console_mode_request,
 823     (dump_func)dump_set_console_info_request,
 824     (dump_func)dump_get_console_info_request,
 825     (dump_func)dump_write_console_input_request,
 826     (dump_func)dump_read_console_input_request,
 827     (dump_func)dump_create_change_notification_request,
 828     (dump_func)dump_create_mapping_request,
 829     (dump_func)dump_open_mapping_request,
 830     (dump_func)dump_get_mapping_info_request,
 831     (dump_func)dump_create_device_request,
 832     (dump_func)dump_create_snapshot_request,
 833     (dump_func)dump_next_process_request,
 834     (dump_func)dump_wait_debug_event_request,
 835     (dump_func)dump_send_debug_event_request,
 836     (dump_func)dump_continue_debug_event_request,
 837     (dump_func)dump_debug_process_request,
 838 };
 839
 840 static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {
 841     (dump_func)dump_new_process_reply,
 842     (dump_func)dump_new_thread_reply,
 843     (dump_func)0,
 844     (dump_func)dump_init_process_reply,
 845     (dump_func)0,
 846     (dump_func)dump_init_thread_reply,
 847     (dump_func)0,
 848     (dump_func)0,
 849     (dump_func)0,
 850     (dump_func)dump_get_process_info_reply,
 851     (dump_func)0,
 852     (dump_func)dump_get_thread_info_reply,
 853     (dump_func)0,
 854     (dump_func)dump_suspend_thread_reply,
 855     (dump_func)dump_resume_thread_reply,
 856     (dump_func)0,
 857     (dump_func)0,
 858     (dump_func)dump_get_apcs_reply,
 859     (dump_func)0,
 860     (dump_func)dump_get_handle_info_reply,
 861     (dump_func)0,
 862     (dump_func)dump_dup_handle_reply,
 863     (dump_func)dump_open_process_reply,
 864     (dump_func)dump_select_reply,
 865     (dump_func)dump_create_event_reply,
 866     (dump_func)0,
 867     (dump_func)dump_open_event_reply,
 868     (dump_func)dump_create_mutex_reply,
 869     (dump_func)0,
 870     (dump_func)dump_open_mutex_reply,
 871     (dump_func)dump_create_semaphore_reply,
 872     (dump_func)dump_release_semaphore_reply,
 873     (dump_func)dump_open_semaphore_reply,
 874     (dump_func)dump_create_file_reply,
 875     (dump_func)dump_alloc_file_handle_reply,
 876     (dump_func)0,
 877     (dump_func)0,
 878     (dump_func)dump_set_file_pointer_reply,
 879     (dump_func)0,
 880     (dump_func)0,
 881     (dump_func)0,
 882     (dump_func)dump_get_file_info_reply,
 883     (dump_func)0,
 884     (dump_func)0,
 885     (dump_func)dump_create_pipe_reply,
 886     (dump_func)dump_create_socket_reply,
 887     (dump_func)dump_accept_socket_reply,
 888     (dump_func)0,
 889     (dump_func)dump_get_socket_event_reply,
 890     (dump_func)0,
 891     (dump_func)dump_alloc_console_reply,
 892     (dump_func)0,
 893     (dump_func)dump_open_console_reply,
 894     (dump_func)0,
 895     (dump_func)dump_get_console_mode_reply,
 896     (dump_func)0,
 897     (dump_func)0,
 898     (dump_func)dump_get_console_info_reply,
 899     (dump_func)dump_write_console_input_reply,
 900     (dump_func)dump_read_console_input_reply,
 901     (dump_func)dump_create_change_notification_reply,
 902     (dump_func)dump_create_mapping_reply,
 903     (dump_func)dump_open_mapping_reply,
 904     (dump_func)dump_get_mapping_info_reply,
 905     (dump_func)dump_create_device_reply,
 906     (dump_func)dump_create_snapshot_reply,
 907     (dump_func)dump_next_process_reply,
 908     (dump_func)dump_wait_debug_event_reply,
 909     (dump_func)dump_send_debug_event_reply,
 910     (dump_func)0,
 911     (dump_func)0,
 912 };
 913
 914 static const char * const req_names[REQ_NB_REQUESTS] = {
 915     "new_process",
 916     "new_thread",
 917     "set_debug",
 918     "init_process",
 919     "init_process_done",
 920     "init_thread",
 921     "get_thread_buffer",
 922     "terminate_process",
 923     "terminate_thread",
 924     "get_process_info",
 925     "set_process_info",
 926     "get_thread_info",
 927     "set_thread_info",
 928     "suspend_thread",
 929     "resume_thread",
 930     "debugger",
 931     "queue_apc",
 932     "get_apcs",
 933     "close_handle",
 934     "get_handle_info",
 935     "set_handle_info",
 936     "dup_handle",
 937     "open_process",
 938     "select",
 939     "create_event",
 940     "event_op",
 941     "open_event",
 942     "create_mutex",
 943     "release_mutex",
 944     "open_mutex",
 945     "create_semaphore",
 946     "release_semaphore",
 947     "open_semaphore",
 948     "create_file",
 949     "alloc_file_handle",
 950     "get_read_fd",
 951     "get_write_fd",
 952     "set_file_pointer",
 953     "truncate_file",
 954     "set_file_time",
 955     "flush_file",
 956     "get_file_info",
 957     "lock_file",
 958     "unlock_file",
 959     "create_pipe",
 960     "create_socket",
 961     "accept_socket",
 962     "set_socket_event",
 963     "get_socket_event",
 964     "enable_socket_event",
 965     "alloc_console",
 966     "free_console",
 967     "open_console",
 968     "set_console_fd",
 969     "get_console_mode",
 970     "set_console_mode",
 971     "set_console_info",
 972     "get_console_info",
 973     "write_console_input",
 974     "read_console_input",
 975     "create_change_notification",
 976     "create_mapping",
 977     "open_mapping",
 978     "get_mapping_info",
 979     "create_device",
 980     "create_snapshot",
 981     "next_process",
 982     "wait_debug_event",
 983     "send_debug_event",
 984     "continue_debug_event",
 985     "debug_process",
 986 };
 987
 988 /* ### make_requests end ### */
 989 /* Everything above this line is generated automatically by tools/make_requests */
 990
 991 void trace_request( enum request req, int fd )
 992 {
 993     current->last_req = req;
 994     if (req < REQ_NB_REQUESTS)
 995     {
 996         fprintf( stderr, "%08x: %s(", (unsigned int)current, req_names[req] );
 997         req_dumpers[req]( current->buffer );
 998     }
 999     else
1000         fprintf( stderr, "%08x: %d(", (unsigned int)current, req );
1001     if (fd != -1) fprintf( stderr, " ) fd=%d\n", fd );
1002     else fprintf( stderr, " )\n" );
1003 }
1004
1005 void trace_timeout(void)
1006 {
1007     fprintf( stderr, "%08x: *timeout*\n", (unsigned int)current );
1008 }
1009
1010 void trace_kill( int exit_code )
1011 {
1012     fprintf( stderr,"%08x: *killed* exit_code=%d\n",
1013              (unsigned int)current, exit_code );
1014 }
1015
1016 void trace_reply( struct thread *thread, unsigned int res, int pass_fd )
1017 {
1018     fprintf( stderr, "%08x: %s() = %d",
1019              (unsigned int)thread, req_names[thread->last_req], res );
1020     if (reply_dumpers[thread->last_req])
1021     {
1022         fprintf( stderr, " {" );
1023         reply_dumpers[thread->last_req]( thread->buffer );
1024         fprintf( stderr, " }" );
1025     }
1026     if (pass_fd != -1) fprintf( stderr, " fd=%d\n", pass_fd );
1027     else fprintf( stderr, "\n" );
1028 }