server/trace.c

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