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