Added beginnings of server-side file handling. Added -debugmsg +server support. Better server request dumping for varargs requests.
diff --git a/server/Makefile.in b/server/Makefile.in index 1dfd55d..e1f28df 100644 --- a/server/Makefile.in +++ b/server/Makefile.in
@@ -7,6 +7,7 @@ C_SRCS = \ event.c \ + file.c \ mutex.c \ object.c \ process.c \
diff --git a/server/event.c b/server/event.c index 2483002..f1da91f 100644 --- a/server/event.c +++ b/server/event.c
@@ -19,19 +19,19 @@ int signaled; /* event has been signaled */ }; -static void dump_event( struct object *obj, int verbose ); +static void event_dump( struct object *obj, int verbose ); static int event_signaled( struct object *obj, struct thread *thread ); static int event_satisfied( struct object *obj, struct thread *thread ); -static void destroy_event( struct object *obj ); +static void event_destroy( struct object *obj ); static const struct object_ops event_ops = { - dump_event, + event_dump, add_queue, remove_queue, event_signaled, event_satisfied, - destroy_event + event_destroy }; @@ -96,7 +96,7 @@ return 1; } -static void dump_event( struct object *obj, int verbose ) +static void event_dump( struct object *obj, int verbose ) { struct event *event = (struct event *)obj; assert( obj->ops == &event_ops ); @@ -119,7 +119,7 @@ return 0; /* Not abandoned */ } -static void destroy_event( struct object *obj ) +static void event_destroy( struct object *obj ) { struct event *event = (struct event *)obj; assert( obj->ops == &event_ops );
diff --git a/server/file.c b/server/file.c new file mode 100644 index 0000000..82319f3 --- /dev/null +++ b/server/file.c
@@ -0,0 +1,195 @@ +/* + * Server-side file management + * + * Copyright (C) 1998 Alexandre Julliard + */ + +#include <assert.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/errno.h> +#include <sys/stat.h> +#include <sys/time.h> +#include <sys/types.h> +#include <time.h> +#include <unistd.h> + +#include "winerror.h" +#include "winnt.h" +#include "server/thread.h" + +struct file +{ + struct object obj; /* object header */ + int fd; /* Unix file descriptor */ + int event; /* possible events on this file */ +}; + +static void file_dump( struct object *obj, int verbose ); +static void file_add_queue( struct object *obj, struct wait_queue_entry *entry ); +static void file_remove_queue( struct object *obj, struct wait_queue_entry *entry ); +static int file_signaled( struct object *obj, struct thread *thread ); +static int file_satisfied( struct object *obj, struct thread *thread ); +static void file_destroy( struct object *obj ); + +static const struct object_ops file_ops = +{ + file_dump, + file_add_queue, + file_remove_queue, + file_signaled, + file_satisfied, + file_destroy +}; + +static void file_event( int fd, int event, void *private ); +static void file_timeout( int fd, void *private ); + +static const struct select_ops select_ops = +{ + file_event, + file_timeout +}; + +struct object *create_file( int fd ) +{ + struct file *file; + int flags; + + if ((flags = fcntl( fd, F_GETFL )) == -1) + { + perror( "fcntl" ); + return NULL; + } + if (!(file = mem_alloc( sizeof(*file) ))) return NULL; + init_object( &file->obj, &file_ops, NULL ); + file->fd = fd; + switch(flags & 3) + { + case O_RDONLY: + file->event = READ_EVENT; + break; + case O_WRONLY: + file->event = WRITE_EVENT; + break; + case O_RDWR: + file->event = READ_EVENT | WRITE_EVENT; + break; + } + CLEAR_ERROR(); + return &file->obj; +} + +static void file_dump( struct object *obj, int verbose ) +{ + struct file *file = (struct file *)obj; + assert( obj->ops == &file_ops ); + printf( "File fd=%d\n", file->fd ); +} + +static void file_add_queue( struct object *obj, struct wait_queue_entry *entry ) +{ + struct file *file = (struct file *)obj; + assert( obj->ops == &file_ops ); + if (!obj->head) /* first on the queue */ + add_select_user( file->fd, READ_EVENT | WRITE_EVENT, &select_ops, file ); + add_queue( obj, entry ); +} + +static void file_remove_queue( struct object *obj, struct wait_queue_entry *entry ) +{ + struct file *file = (struct file *)grab_object(obj); + assert( obj->ops == &file_ops ); + + remove_queue( obj, entry ); + if (!obj->head) /* last on the queue is gone */ + remove_select_user( file->fd ); + release_object( obj ); +} + +static int file_signaled( struct object *obj, struct thread *thread ) +{ + fd_set read_fds, write_fds; + struct timeval tv = { 0, 0 }; + + struct file *file = (struct file *)obj; + assert( obj->ops == &file_ops ); + + FD_ZERO( &read_fds ); + FD_ZERO( &write_fds ); + if (file->event & READ_EVENT) FD_SET( file->fd, &read_fds ); + if (file->event & WRITE_EVENT) FD_SET( file->fd, &write_fds ); + return select( file->fd + 1, &read_fds, &write_fds, NULL, &tv ) > 0; +} + +static int file_satisfied( struct object *obj, struct thread *thread ) +{ + /* Nothing to do */ + return 0; /* Not abandoned */ +} + +static void file_destroy( struct object *obj ) +{ + struct file *file = (struct file *)obj; + assert( obj->ops == &file_ops ); + close( file->fd ); + free( file ); +} + +static void file_event( int fd, int event, void *private ) +{ + struct file *file = (struct file *)private; + assert( file ); + + wake_up( &file->obj, 0 ); +} + +static void file_timeout( int fd, void *private ) +{ + /* we never set a timeout on a file */ + assert( 0 ); +} + +int file_get_unix_handle( int handle, unsigned int access ) +{ + struct file *file; + int unix_handle; + + if (!(file = (struct file *)get_handle_obj( current->process, handle, + access, &file_ops ))) + return -1; + unix_handle = dup( file->fd ); + release_object( file ); + return unix_handle; +} + +int get_file_info( int handle, struct get_file_info_reply *reply ) +{ + struct file *file; + struct stat st; + + if (!(file = (struct file *)get_handle_obj( current->process, handle, + 0, &file_ops ))) + return 0; + if (fstat( file->fd, &st ) == -1) + { + /* file_set_error(); */ + release_object( file ); + return 0; + } + if (S_ISDIR(st.st_mode)) reply->attr = FILE_ATTRIBUTE_DIRECTORY; + else reply->attr = FILE_ATTRIBUTE_ARCHIVE; + if (!(st.st_mode & S_IWUSR)) reply->attr |= FILE_ATTRIBUTE_READONLY; + reply->access_time = st.st_atime; + reply->write_time = st.st_mtime; + reply->size_high = 0; + reply->size_low = S_ISDIR(st.st_mode) ? 0 : st.st_size; + reply->links = st.st_nlink; + reply->index_high = st.st_dev; + reply->index_low = st.st_ino; + reply->serial = 0; /* FIXME */ + + release_object( file ); + return 1; +}
diff --git a/server/mutex.c b/server/mutex.c index aee0771..375294f 100644 --- a/server/mutex.c +++ b/server/mutex.c
@@ -22,19 +22,19 @@ struct mutex *prev; }; -static void dump_mutex( struct object *obj, int verbose ); +static void mutex_dump( struct object *obj, int verbose ); static int mutex_signaled( struct object *obj, struct thread *thread ); static int mutex_satisfied( struct object *obj, struct thread *thread ); -static void destroy_mutex( struct object *obj ); +static void mutex_destroy( struct object *obj ); static const struct object_ops mutex_ops = { - dump_mutex, + mutex_dump, add_queue, remove_queue, mutex_signaled, mutex_satisfied, - destroy_mutex + mutex_destroy }; @@ -103,7 +103,7 @@ } } -static void dump_mutex( struct object *obj, int verbose ) +static void mutex_dump( struct object *obj, int verbose ) { struct mutex *mutex = (struct mutex *)obj; assert( obj->ops == &mutex_ops ); @@ -136,7 +136,7 @@ return 1; } -static void destroy_mutex( struct object *obj ) +static void mutex_destroy( struct object *obj ) { struct mutex *mutex = (struct mutex *)obj; assert( obj->ops == &mutex_ops );
diff --git a/server/process.c b/server/process.c index 79b3833..da3f06c 100644 --- a/server/process.c +++ b/server/process.c
@@ -54,21 +54,21 @@ /* process operations */ -static void dump_process( struct object *obj, int verbose ); +static void process_dump( struct object *obj, int verbose ); static int process_signaled( struct object *obj, struct thread *thread ); static int process_satisfied( struct object *obj, struct thread *thread ); -static void destroy_process( struct object *obj ); +static void process_destroy( struct object *obj ); static void free_handles( struct process *process ); static int copy_handle_table( struct process *process, struct process *parent ); static const struct object_ops process_ops = { - dump_process, + process_dump, add_queue, remove_queue, process_signaled, process_satisfied, - destroy_process + process_destroy }; /* create a new process */ @@ -100,7 +100,7 @@ } /* destroy a process when its refcount is 0 */ -static void destroy_process( struct object *obj ) +static void process_destroy( struct object *obj ) { struct process *process = (struct process *)obj; assert( obj->ops == &process_ops ); @@ -116,7 +116,7 @@ } /* dump a process on stdout for debugging purposes */ -static void dump_process( struct object *obj, int verbose ) +static void process_dump( struct object *obj, int verbose ) { struct process *process = (struct process *)obj; assert( obj->ops == &process_ops );
diff --git a/server/request.c b/server/request.c index 6ce5b35..4c14c48 100644 --- a/server/request.c +++ b/server/request.c
@@ -152,6 +152,14 @@ send_reply( current, -1, 0 ); } +/* set the debug level */ +DECL_HANDLER(set_debug) +{ + debug_level = req->level; + CLEAR_ERROR(); + send_reply( current, -1, 0 ); +} + /* terminate a process */ DECL_HANDLER(terminate_process) { @@ -372,3 +380,38 @@ send_reply( current, -1, 1, &reply, sizeof(reply) ); } +/* create a file */ +DECL_HANDLER(create_file) +{ + struct create_file_reply reply = { -1 }; + struct object *obj; + int new_fd; + + if ((new_fd = dup(fd)) == -1) + { + SET_ERROR( ERROR_TOO_MANY_OPEN_FILES ); + goto done; + } + if ((obj = create_file( new_fd )) != NULL) + { + reply.handle = alloc_handle( current->process, obj, req->access, req->inherit ); + release_object( obj ); + } + done: + send_reply( current, -1, 1, &reply, sizeof(reply) ); +} + +/* get a Unix handle to a file */ +DECL_HANDLER(get_unix_handle) +{ + int handle = file_get_unix_handle( req->handle, req->access ); + send_reply( current, handle, 0 ); +} + +/* get a file information */ +DECL_HANDLER(get_file_info) +{ + struct get_file_info_reply reply; + get_file_info( req->handle, &reply ); + send_reply( current, -1, 1, &reply, sizeof(reply) ); +}
diff --git a/server/semaphore.c b/server/semaphore.c index 2753d96..cd77d16 100644 --- a/server/semaphore.c +++ b/server/semaphore.c
@@ -19,19 +19,19 @@ unsigned int max; /* maximum possible count */ }; -static void dump_semaphore( struct object *obj, int verbose ); +static void semaphore_dump( struct object *obj, int verbose ); static int semaphore_signaled( struct object *obj, struct thread *thread ); static int semaphore_satisfied( struct object *obj, struct thread *thread ); -static void destroy_semaphore( struct object *obj ); +static void semaphore_destroy( struct object *obj ); static const struct object_ops semaphore_ops = { - dump_semaphore, + semaphore_dump, add_queue, remove_queue, semaphore_signaled, semaphore_satisfied, - destroy_semaphore + semaphore_destroy }; @@ -89,7 +89,7 @@ return 1; } -static void dump_semaphore( struct object *obj, int verbose ) +static void semaphore_dump( struct object *obj, int verbose ) { struct semaphore *sem = (struct semaphore *)obj; assert( obj->ops == &semaphore_ops ); @@ -112,7 +112,7 @@ return 0; /* not abandoned */ } -static void destroy_semaphore( struct object *obj ) +static void semaphore_destroy( struct object *obj ) { struct semaphore *sem = (struct semaphore *)obj; assert( obj->ops == &semaphore_ops );
diff --git a/server/trace.c b/server/trace.c index 0850fd5..1dc815c 100644 --- a/server/trace.c +++ b/server/trace.c
@@ -6,64 +6,81 @@ #include "server.h" #include "server/thread.h" -static void dump_new_thread_request( struct new_thread_request *req ) +static int dump_new_thread_request( struct new_thread_request *req, int len ) { printf( " pid=%p", req->pid ); + return (int)sizeof(*req); } -static void dump_new_thread_reply( struct new_thread_reply *req ) +static int dump_new_thread_reply( struct new_thread_reply *req, int len ) { printf( " tid=%p,", req->tid ); printf( " thandle=%d,", req->thandle ); printf( " pid=%p,", req->pid ); printf( " phandle=%d", req->phandle ); + return (int)sizeof(*req); } -static void dump_init_thread_request( struct init_thread_request *req ) +static int dump_set_debug_request( struct set_debug_request *req, int len ) { - printf( " unix_pid=%d", req->unix_pid ); + printf( " level=%d", req->level ); + return (int)sizeof(*req); } -static void dump_terminate_process_request( struct terminate_process_request *req ) +static int dump_init_thread_request( struct init_thread_request *req, int len ) +{ + printf( " unix_pid=%d,", req->unix_pid ); + printf( " cmd_line=\"%.*s\"", len - (int)sizeof(*req), (char *)(req+1) ); + return len; +} + +static int dump_terminate_process_request( struct terminate_process_request *req, int len ) { printf( " handle=%d,", req->handle ); printf( " exit_code=%d", req->exit_code ); + return (int)sizeof(*req); } -static void dump_terminate_thread_request( struct terminate_thread_request *req ) +static int dump_terminate_thread_request( struct terminate_thread_request *req, int len ) { printf( " handle=%d,", req->handle ); printf( " exit_code=%d", req->exit_code ); + return (int)sizeof(*req); } -static void dump_get_process_info_request( struct get_process_info_request *req ) +static int dump_get_process_info_request( struct get_process_info_request *req, int len ) { printf( " handle=%d", req->handle ); + return (int)sizeof(*req); } -static void dump_get_process_info_reply( struct get_process_info_reply *req ) +static int dump_get_process_info_reply( struct get_process_info_reply *req, int len ) { printf( " pid=%p,", req->pid ); printf( " exit_code=%d", req->exit_code ); + return (int)sizeof(*req); } -static void dump_get_thread_info_request( struct get_thread_info_request *req ) +static int dump_get_thread_info_request( struct get_thread_info_request *req, int len ) { printf( " handle=%d", req->handle ); + return (int)sizeof(*req); } -static void dump_get_thread_info_reply( struct get_thread_info_reply *req ) +static int dump_get_thread_info_reply( struct get_thread_info_reply *req, int len ) { printf( " pid=%p,", req->pid ); printf( " exit_code=%d", req->exit_code ); + return (int)sizeof(*req); } -static void dump_close_handle_request( struct close_handle_request *req ) +static int dump_close_handle_request( struct close_handle_request *req, int len ) { printf( " handle=%d", req->handle ); + return (int)sizeof(*req); } -static void dump_dup_handle_request( struct dup_handle_request *req ) +static int dump_dup_handle_request( struct dup_handle_request *req, int len ) { printf( " src_process=%d,", req->src_process ); printf( " src_handle=%d,", req->src_handle ); @@ -72,171 +89,222 @@ printf( " access=%08x,", req->access ); printf( " inherit=%d,", req->inherit ); printf( " options=%d", req->options ); + return (int)sizeof(*req); } -static void dump_dup_handle_reply( struct dup_handle_reply *req ) +static int dump_dup_handle_reply( struct dup_handle_reply *req, int len ) { printf( " handle=%d", req->handle ); + return (int)sizeof(*req); } -static void dump_open_process_request( struct open_process_request *req ) +static int dump_open_process_request( struct open_process_request *req, int len ) { printf( " pid=%p,", req->pid ); printf( " access=%08x,", req->access ); printf( " inherit=%d", req->inherit ); + return (int)sizeof(*req); } -static void dump_open_process_reply( struct open_process_reply *req ) +static int dump_open_process_reply( struct open_process_reply *req, int len ) { printf( " handle=%d", req->handle ); + return (int)sizeof(*req); } -static void dump_select_request( struct select_request *req ) +static int dump_select_request( struct select_request *req, int len ) { printf( " count=%d,", req->count ); printf( " flags=%d,", req->flags ); printf( " timeout=%d", req->timeout ); + return (int)sizeof(*req); } -static void dump_select_reply( struct select_reply *req ) +static int dump_select_reply( struct select_reply *req, int len ) { printf( " signaled=%d", req->signaled ); + return (int)sizeof(*req); } -static void dump_create_event_request( struct create_event_request *req ) +static int dump_create_event_request( struct create_event_request *req, int len ) { printf( " manual_reset=%d,", req->manual_reset ); printf( " initial_state=%d,", req->initial_state ); - printf( " inherit=%d", req->inherit ); + printf( " inherit=%d,", req->inherit ); + printf( " name=\"%.*s\"", len - (int)sizeof(*req), (char *)(req+1) ); + return len; } -static void dump_create_event_reply( struct create_event_reply *req ) +static int dump_create_event_reply( struct create_event_reply *req, int len ) { printf( " handle=%d", req->handle ); + return (int)sizeof(*req); } -static void dump_event_op_request( struct event_op_request *req ) +static int dump_event_op_request( struct event_op_request *req, int len ) { printf( " handle=%d,", req->handle ); printf( " op=%d", req->op ); + return (int)sizeof(*req); } -static void dump_create_mutex_request( struct create_mutex_request *req ) +static int dump_create_mutex_request( struct create_mutex_request *req, int len ) { printf( " owned=%d,", req->owned ); - printf( " inherit=%d", req->inherit ); + printf( " inherit=%d,", req->inherit ); + printf( " name=\"%.*s\"", len - (int)sizeof(*req), (char *)(req+1) ); + return len; } -static void dump_create_mutex_reply( struct create_mutex_reply *req ) +static int dump_create_mutex_reply( struct create_mutex_reply *req, int len ) { printf( " handle=%d", req->handle ); + return (int)sizeof(*req); } -static void dump_release_mutex_request( struct release_mutex_request *req ) +static int dump_release_mutex_request( struct release_mutex_request *req, int len ) { printf( " handle=%d", req->handle ); + return (int)sizeof(*req); } -static void dump_create_semaphore_request( struct create_semaphore_request *req ) +static int dump_create_semaphore_request( struct create_semaphore_request *req, int len ) { printf( " initial=%08x,", req->initial ); printf( " max=%08x,", req->max ); printf( " inherit=%d", req->inherit ); + return (int)sizeof(*req); } -static void dump_create_semaphore_reply( struct create_semaphore_reply *req ) +static int dump_create_semaphore_reply( struct create_semaphore_reply *req, int len ) { printf( " handle=%d", req->handle ); + return (int)sizeof(*req); } -static void dump_release_semaphore_request( struct release_semaphore_request *req ) +static int dump_release_semaphore_request( struct release_semaphore_request *req, int len ) { printf( " handle=%d,", req->handle ); printf( " count=%08x", req->count ); + return (int)sizeof(*req); } -static void dump_release_semaphore_reply( struct release_semaphore_reply *req ) +static int dump_release_semaphore_reply( struct release_semaphore_reply *req, int len ) { printf( " prev_count=%08x", req->prev_count ); + return (int)sizeof(*req); } -static void dump_open_named_obj_request( struct open_named_obj_request *req ) +static int dump_open_named_obj_request( struct open_named_obj_request *req, int len ) { printf( " type=%d,", req->type ); printf( " access=%08x,", req->access ); printf( " inherit=%d", req->inherit ); + return (int)sizeof(*req); } -static void dump_open_named_obj_reply( struct open_named_obj_reply *req ) +static int dump_open_named_obj_reply( struct open_named_obj_reply *req, int len ) { printf( " handle=%d", req->handle ); + return (int)sizeof(*req); +} + +static int dump_create_file_request( struct create_file_request *req, int len ) +{ + printf( " access=%08x,", req->access ); + printf( " inherit=%d", req->inherit ); + return (int)sizeof(*req); +} + +static int dump_create_file_reply( struct create_file_reply *req, int len ) +{ + printf( " handle=%d", req->handle ); + return (int)sizeof(*req); +} + +static int dump_get_unix_handle_request( struct get_unix_handle_request *req, int len ) +{ + printf( " handle=%d,", req->handle ); + printf( " access=%08x", req->access ); + return (int)sizeof(*req); +} + +static int dump_get_file_info_request( struct get_file_info_request *req, int len ) +{ + printf( " handle=%d", req->handle ); + return (int)sizeof(*req); +} + +static int dump_get_file_info_reply( struct get_file_info_reply *req, int len ) +{ + printf( " attr=%d,", req->attr ); + printf( " access_time=%ld,", req->access_time ); + printf( " write_time=%ld,", req->write_time ); + printf( " size_high=%d,", req->size_high ); + printf( " size_low=%d,", req->size_low ); + printf( " links=%d,", req->links ); + printf( " index_high=%d,", req->index_high ); + printf( " index_low=%d,", req->index_low ); + printf( " serial=%08x", req->serial ); + return (int)sizeof(*req); } struct dumper { - void (*dump_req)(); - void (*dump_reply)(); - unsigned int size; + int (*dump_req)( void *data, int len ); + void (*dump_reply)( void *data ); }; static const struct dumper dumpers[REQ_NB_REQUESTS] = { - { (void(*)())dump_new_thread_request, - (void(*)())dump_new_thread_reply, - sizeof(struct new_thread_request) }, - { (void(*)())dump_init_thread_request, - (void(*)())0, - sizeof(struct init_thread_request) }, - { (void(*)())dump_terminate_process_request, - (void(*)())0, - sizeof(struct terminate_process_request) }, - { (void(*)())dump_terminate_thread_request, - (void(*)())0, - sizeof(struct terminate_thread_request) }, - { (void(*)())dump_get_process_info_request, - (void(*)())dump_get_process_info_reply, - sizeof(struct get_process_info_request) }, - { (void(*)())dump_get_thread_info_request, - (void(*)())dump_get_thread_info_reply, - sizeof(struct get_thread_info_request) }, - { (void(*)())dump_close_handle_request, - (void(*)())0, - sizeof(struct close_handle_request) }, - { (void(*)())dump_dup_handle_request, - (void(*)())dump_dup_handle_reply, - sizeof(struct dup_handle_request) }, - { (void(*)())dump_open_process_request, - (void(*)())dump_open_process_reply, - sizeof(struct open_process_request) }, - { (void(*)())dump_select_request, - (void(*)())dump_select_reply, - sizeof(struct select_request) }, - { (void(*)())dump_create_event_request, - (void(*)())dump_create_event_reply, - sizeof(struct create_event_request) }, - { (void(*)())dump_event_op_request, - (void(*)())0, - sizeof(struct event_op_request) }, - { (void(*)())dump_create_mutex_request, - (void(*)())dump_create_mutex_reply, - sizeof(struct create_mutex_request) }, - { (void(*)())dump_release_mutex_request, - (void(*)())0, - sizeof(struct release_mutex_request) }, - { (void(*)())dump_create_semaphore_request, - (void(*)())dump_create_semaphore_reply, - sizeof(struct create_semaphore_request) }, - { (void(*)())dump_release_semaphore_request, - (void(*)())dump_release_semaphore_reply, - sizeof(struct release_semaphore_request) }, - { (void(*)())dump_open_named_obj_request, - (void(*)())dump_open_named_obj_reply, - sizeof(struct open_named_obj_request) }, + { (int(*)(void *,int))dump_new_thread_request, + (void(*)())dump_new_thread_reply }, + { (int(*)(void *,int))dump_set_debug_request, + (void(*)())0 }, + { (int(*)(void *,int))dump_init_thread_request, + (void(*)())0 }, + { (int(*)(void *,int))dump_terminate_process_request, + (void(*)())0 }, + { (int(*)(void *,int))dump_terminate_thread_request, + (void(*)())0 }, + { (int(*)(void *,int))dump_get_process_info_request, + (void(*)())dump_get_process_info_reply }, + { (int(*)(void *,int))dump_get_thread_info_request, + (void(*)())dump_get_thread_info_reply }, + { (int(*)(void *,int))dump_close_handle_request, + (void(*)())0 }, + { (int(*)(void *,int))dump_dup_handle_request, + (void(*)())dump_dup_handle_reply }, + { (int(*)(void *,int))dump_open_process_request, + (void(*)())dump_open_process_reply }, + { (int(*)(void *,int))dump_select_request, + (void(*)())dump_select_reply }, + { (int(*)(void *,int))dump_create_event_request, + (void(*)())dump_create_event_reply }, + { (int(*)(void *,int))dump_event_op_request, + (void(*)())0 }, + { (int(*)(void *,int))dump_create_mutex_request, + (void(*)())dump_create_mutex_reply }, + { (int(*)(void *,int))dump_release_mutex_request, + (void(*)())0 }, + { (int(*)(void *,int))dump_create_semaphore_request, + (void(*)())dump_create_semaphore_reply }, + { (int(*)(void *,int))dump_release_semaphore_request, + (void(*)())dump_release_semaphore_reply }, + { (int(*)(void *,int))dump_open_named_obj_request, + (void(*)())dump_open_named_obj_reply }, + { (int(*)(void *,int))dump_create_file_request, + (void(*)())dump_create_file_reply }, + { (int(*)(void *,int))dump_get_unix_handle_request, + (void(*)())0 }, + { (int(*)(void *,int))dump_get_file_info_request, + (void(*)())dump_get_file_info_reply }, }; static const char * const req_names[REQ_NB_REQUESTS] = { "new_thread", + "set_debug", "init_thread", "terminate_process", "terminate_thread", @@ -253,17 +321,20 @@ "create_semaphore", "release_semaphore", "open_named_obj", + "create_file", + "get_unix_handle", + "get_file_info", }; void trace_request( enum request req, void *data, int len, int fd ) { + int size; current->last_req = req; printf( "%08x: %s(", (unsigned int)current, req_names[req] ); - dumpers[req].dump_req( data ); - if (len > dumpers[req].size) + size = dumpers[req].dump_req( data, len ); + if ((len -= size) > 0) { - unsigned char *ptr = (unsigned char *)data + dumpers[req].size; - len -= dumpers[req].size; + unsigned char *ptr = (unsigned char *)data + size; while (len--) printf( ", %02x", *ptr++ ); } if (fd != -1) printf( " ) fd=%d\n", fd );