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