diff --git a/dlls/ntdll/file.c b/dlls/ntdll/file.c index cefc1ddd444..e1583da3fe4 100644 --- a/dlls/ntdll/file.c +++ b/dlls/ntdll/file.c @@ -420,9 +420,8 @@ static NTSTATUS irp_completion( void *user, IO_STATUS_BLOCK *io, NTSTATUS status if (status == STATUS_ALERTED) { - SERVER_START_REQ( get_irp_result ) + SERVER_START_REQ( get_async_result ) { - req->handle = wine_server_obj_handle( async->io.handle ); req->user_arg = wine_server_client_ptr( async ); wine_server_set_reply( req, async->buffer, async->size ); status = wine_server_call( req ); diff --git a/include/wine/server_protocol.h b/include/wine/server_protocol.h index 8fec67fabea..ee9fdd12eb8 100644 --- a/include/wine/server_protocol.h +++ b/include/wine/server_protocol.h @@ -3223,6 +3223,22 @@ struct cancel_async_reply +struct get_async_result_request +{ + struct request_header __header; + char __pad_12[4]; + client_ptr_t user_arg; +}; +struct get_async_result_reply +{ + struct reply_header __header; + data_size_t size; + /* VARARG(out_data,bytes); */ + char __pad_12[4]; +}; + + + struct read_request { struct request_header __header; @@ -3294,22 +3310,6 @@ struct set_irp_result_reply -struct get_irp_result_request -{ - struct request_header __header; - obj_handle_t handle; - client_ptr_t user_arg; -}; -struct get_irp_result_reply -{ - struct reply_header __header; - data_size_t size; - /* VARARG(out_data,bytes); */ - char __pad_12[4]; -}; - - - struct create_named_pipe_request { struct request_header __header; @@ -5693,11 +5693,11 @@ enum request REQ_set_serial_info, REQ_register_async, REQ_cancel_async, + REQ_get_async_result, REQ_read, REQ_write, REQ_ioctl, REQ_set_irp_result, - REQ_get_irp_result, REQ_create_named_pipe, REQ_get_named_pipe_info, REQ_set_named_pipe_info, @@ -5983,11 +5983,11 @@ union generic_request struct set_serial_info_request set_serial_info_request; struct register_async_request register_async_request; struct cancel_async_request cancel_async_request; + struct get_async_result_request get_async_result_request; struct read_request read_request; struct write_request write_request; struct ioctl_request ioctl_request; struct set_irp_result_request set_irp_result_request; - struct get_irp_result_request get_irp_result_request; struct create_named_pipe_request create_named_pipe_request; struct get_named_pipe_info_request get_named_pipe_info_request; struct set_named_pipe_info_request set_named_pipe_info_request; @@ -6271,11 +6271,11 @@ union generic_reply struct set_serial_info_reply set_serial_info_reply; struct register_async_reply register_async_reply; struct cancel_async_reply cancel_async_reply; + struct get_async_result_reply get_async_result_reply; struct read_reply read_reply; struct write_reply write_reply; struct ioctl_reply ioctl_reply; struct set_irp_result_reply set_irp_result_reply; - struct get_irp_result_reply get_irp_result_reply; struct create_named_pipe_reply create_named_pipe_reply; struct get_named_pipe_info_reply get_named_pipe_info_reply; struct set_named_pipe_info_reply set_named_pipe_info_reply; @@ -6412,6 +6412,6 @@ union generic_reply struct terminate_job_reply terminate_job_reply; }; -#define SERVER_PROTOCOL_VERSION 523 +#define SERVER_PROTOCOL_VERSION 524 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */ diff --git a/server/async.c b/server/async.c index 562fcd02032..ec46103dd49 100644 --- a/server/async.c +++ b/server/async.c @@ -471,3 +471,35 @@ DECL_HANDLER(cancel_async) release_object( obj ); } } + +/* get async result from associated iosb */ +DECL_HANDLER(get_async_result) +{ + struct iosb *iosb = NULL; + struct async *async; + + LIST_FOR_EACH_ENTRY( async, ¤t->process->asyncs, struct async, process_entry ) + if (async->data.arg == req->user_arg) + { + iosb = async->iosb; + break; + } + + if (!iosb) + { + set_error( STATUS_INVALID_PARAMETER ); + return; + } + + if (iosb->out_data) + { + data_size_t size = min( iosb->out_size, get_reply_max_size() ); + if (size) + { + set_reply_data_ptr( iosb->out_data, size ); + iosb->out_data = NULL; + } + } + reply->size = iosb->result; + set_error( iosb->status ); +} diff --git a/server/device.c b/server/device.c index 60a15e2a6fb..975507e42f9 100644 --- a/server/device.c +++ b/server/device.c @@ -297,13 +297,9 @@ static void set_irp_result( struct irp_call *irp, unsigned int status, } wake_up( &irp->obj, 0 ); - if (status != STATUS_ALERTED) - { - /* remove it from the device queue */ - /* (for STATUS_ALERTED this will be done in get_irp_result) */ - list_remove( &irp->dev_entry ); - release_object( irp ); /* no longer on the device queue */ - } + /* remove it from the device queue */ + list_remove( &irp->dev_entry ); + release_object( irp ); /* no longer on the device queue */ release_object( file ); } @@ -445,18 +441,6 @@ static void device_file_destroy( struct object *obj ) release_object( file->device ); } -static struct irp_call *find_irp_call( struct device_file *file, struct thread *thread, - client_ptr_t user_arg ) -{ - struct irp_call *irp; - - LIST_FOR_EACH_ENTRY( irp, &file->requests, struct irp_call, dev_entry ) - if (irp->thread == thread && irp->user_arg == user_arg) return irp; - - set_error( STATUS_INVALID_PARAMETER ); - return NULL; -} - static void set_file_user_ptr( struct device_file *file, client_ptr_t ptr ) { struct irp_call *irp; @@ -810,34 +794,3 @@ DECL_HANDLER(set_irp_result) release_object( irp ); } } - - -/* retrieve results of an async irp */ -DECL_HANDLER(get_irp_result) -{ - struct device_file *file; - struct irp_call *irp; - - if (!(file = (struct device_file *)get_handle_obj( current->process, req->handle, - 0, &device_file_ops ))) - return; - - if ((irp = find_irp_call( file, current, req->user_arg ))) - { - struct iosb *iosb = irp->iosb; - if (iosb->out_data) - { - data_size_t size = min( iosb->out_size, get_reply_max_size() ); - if (size) - { - set_reply_data_ptr( iosb->out_data, size ); - iosb->out_data = NULL; - } - } - reply->size = iosb->result; - set_error( iosb->status ); - list_remove( &irp->dev_entry ); - release_object( irp ); /* no longer on the device queue */ - } - release_object( file ); -} diff --git a/server/protocol.def b/server/protocol.def index 9344da2db24..60865a6ffc2 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -2350,6 +2350,15 @@ enum message_type @END +/* Retrieve results of an async */ +@REQ(get_async_result) + client_ptr_t user_arg; /* user arg used to identify async */ +@REPLY + data_size_t size; /* result size (input or output depending on the operation) */ + VARARG(out_data,bytes); /* iosb output data */ +@END + + /* Perform a read on a file object */ @REQ(read) int blocking; /* whether it's a blocking read */ @@ -2398,16 +2407,6 @@ enum message_type @END -/* Retrieve results of an async irp */ -@REQ(get_irp_result) - obj_handle_t handle; /* handle to the device */ - client_ptr_t user_arg; /* user arg used to identify the request */ -@REPLY - data_size_t size; /* result size (input or output depending on the operation) */ - VARARG(out_data,bytes); /* irp output data */ -@END - - /* Create a named pipe */ @REQ(create_named_pipe) unsigned int access; diff --git a/server/request.h b/server/request.h index 43752e8d732..cd396ee3df4 100644 --- a/server/request.h +++ b/server/request.h @@ -256,11 +256,11 @@ DECL_HANDLER(get_serial_info); DECL_HANDLER(set_serial_info); DECL_HANDLER(register_async); DECL_HANDLER(cancel_async); +DECL_HANDLER(get_async_result); DECL_HANDLER(read); DECL_HANDLER(write); DECL_HANDLER(ioctl); DECL_HANDLER(set_irp_result); -DECL_HANDLER(get_irp_result); DECL_HANDLER(create_named_pipe); DECL_HANDLER(get_named_pipe_info); DECL_HANDLER(set_named_pipe_info); @@ -545,11 +545,11 @@ static const req_handler req_handlers[REQ_NB_REQUESTS] = (req_handler)req_set_serial_info, (req_handler)req_register_async, (req_handler)req_cancel_async, + (req_handler)req_get_async_result, (req_handler)req_read, (req_handler)req_write, (req_handler)req_ioctl, (req_handler)req_set_irp_result, - (req_handler)req_get_irp_result, (req_handler)req_create_named_pipe, (req_handler)req_get_named_pipe_info, (req_handler)req_set_named_pipe_info, @@ -1580,6 +1580,10 @@ C_ASSERT( FIELD_OFFSET(struct cancel_async_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct cancel_async_request, iosb) == 16 ); C_ASSERT( FIELD_OFFSET(struct cancel_async_request, only_thread) == 24 ); C_ASSERT( sizeof(struct cancel_async_request) == 32 ); +C_ASSERT( FIELD_OFFSET(struct get_async_result_request, user_arg) == 16 ); +C_ASSERT( sizeof(struct get_async_result_request) == 24 ); +C_ASSERT( FIELD_OFFSET(struct get_async_result_reply, size) == 8 ); +C_ASSERT( sizeof(struct get_async_result_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct read_request, blocking) == 12 ); C_ASSERT( FIELD_OFFSET(struct read_request, async) == 16 ); C_ASSERT( FIELD_OFFSET(struct read_request, pos) == 56 ); @@ -1607,11 +1611,6 @@ C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, status) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, size) == 20 ); C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, file_ptr) == 24 ); C_ASSERT( sizeof(struct set_irp_result_request) == 32 ); -C_ASSERT( FIELD_OFFSET(struct get_irp_result_request, handle) == 12 ); -C_ASSERT( FIELD_OFFSET(struct get_irp_result_request, user_arg) == 16 ); -C_ASSERT( sizeof(struct get_irp_result_request) == 24 ); -C_ASSERT( FIELD_OFFSET(struct get_irp_result_reply, size) == 8 ); -C_ASSERT( sizeof(struct get_irp_result_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, options) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, sharing) == 20 ); diff --git a/server/trace.c b/server/trace.c index f7e114b2f4a..e0ce45af6d4 100644 --- a/server/trace.c +++ b/server/trace.c @@ -2870,6 +2870,17 @@ static void dump_cancel_async_request( const struct cancel_async_request *req ) fprintf( stderr, ", only_thread=%d", req->only_thread ); } +static void dump_get_async_result_request( const struct get_async_result_request *req ) +{ + dump_uint64( " user_arg=", &req->user_arg ); +} + +static void dump_get_async_result_reply( const struct get_async_result_reply *req ) +{ + fprintf( stderr, " size=%u", req->size ); + dump_varargs_bytes( ", out_data=", cur_size ); +} + static void dump_read_request( const struct read_request *req ) { fprintf( stderr, " blocking=%d", req->blocking ); @@ -2923,18 +2934,6 @@ static void dump_set_irp_result_request( const struct set_irp_result_request *re dump_varargs_bytes( ", data=", cur_size ); } -static void dump_get_irp_result_request( const struct get_irp_result_request *req ) -{ - fprintf( stderr, " handle=%04x", req->handle ); - dump_uint64( ", user_arg=", &req->user_arg ); -} - -static void dump_get_irp_result_reply( const struct get_irp_result_reply *req ) -{ - fprintf( stderr, " size=%u", req->size ); - dump_varargs_bytes( ", out_data=", cur_size ); -} - static void dump_create_named_pipe_request( const struct create_named_pipe_request *req ) { fprintf( stderr, " access=%08x", req->access ); @@ -4605,11 +4604,11 @@ static const dump_func req_dumpers[REQ_NB_REQUESTS] = { (dump_func)dump_set_serial_info_request, (dump_func)dump_register_async_request, (dump_func)dump_cancel_async_request, + (dump_func)dump_get_async_result_request, (dump_func)dump_read_request, (dump_func)dump_write_request, (dump_func)dump_ioctl_request, (dump_func)dump_set_irp_result_request, - (dump_func)dump_get_irp_result_request, (dump_func)dump_create_named_pipe_request, (dump_func)dump_get_named_pipe_info_request, (dump_func)dump_set_named_pipe_info_request, @@ -4891,11 +4890,11 @@ static const dump_func reply_dumpers[REQ_NB_REQUESTS] = { NULL, NULL, NULL, + (dump_func)dump_get_async_result_reply, (dump_func)dump_read_reply, (dump_func)dump_write_reply, (dump_func)dump_ioctl_reply, NULL, - (dump_func)dump_get_irp_result_reply, (dump_func)dump_create_named_pipe_reply, (dump_func)dump_get_named_pipe_info_reply, NULL, @@ -5177,11 +5176,11 @@ static const char * const req_names[REQ_NB_REQUESTS] = { "set_serial_info", "register_async", "cancel_async", + "get_async_result", "read", "write", "ioctl", "set_irp_result", - "get_irp_result", "create_named_pipe", "get_named_pipe_info", "set_named_pipe_info",