wine-commits May 2015

wine-commits@winehq.org

2 participants
428 discussions

Alexandre Julliard : server: Add a common structure to store irp parameters.
by Alexandre Julliard 06 May '15

06 May '15

Module: wine Branch: master Commit: 311f78628618d25afa78149bedf9a3bce186c68b URL: http://source.winehq.org/git/wine.git/?a=commit;h=311f78628618d25afa78149be… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Wed May 6 11:21:40 2015 +0900 server: Add a common structure to store irp parameters. --- dlls/ntoskrnl.exe/ntoskrnl.c | 11 +++++------ include/wine/server_protocol.h | 31 ++++++++++++++++++++++++++----- server/device.c | 35 ++++++++++++++++++++++------------- server/protocol.def | 27 ++++++++++++++++++++++++--- server/request.h | 18 +++++++++--------- server/trace.c | 33 +++++++++++++++++++++++++++++---- tools/make_requests | 1 + 7 files changed, 116 insertions(+), 40 deletions(-) Diff: http://source.winehq.org/git/wine.git/?a=commitdiff;h=311f78628618d25afa781…

1 0

Alexandre Julliard : server: Implement read and write requests for device files.
by Alexandre Julliard 06 May '15

06 May '15

Module: wine Branch: master Commit: faa1db4d13fe3d87075b47f3987d38de3bf9b505 URL: http://source.winehq.org/git/wine.git/?a=commit;h=faa1db4d13fe3d87075b47f39… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Tue May 5 12:51:11 2015 +0900 server: Implement read and write requests for device files. --- server/device.c | 95 +++++++++++++++++++++++++++++++++++++++++---------------- 1 file changed, 68 insertions(+), 27 deletions(-) diff --git a/server/device.c b/server/device.c index 9301f31..353b9a5 100644 --- a/server/device.c +++ b/server/device.c @@ -128,6 +128,10 @@ static void device_destroy( struct object *obj ); static struct object *device_open_file( struct object *obj, unsigned int access, unsigned int sharing, unsigned int options ); static enum server_fd_type device_get_fd_type( struct fd *fd ); +static obj_handle_t device_read( struct fd *fd, const async_data_t *async_data, int blocking, + file_pos_t pos ); +static obj_handle_t device_write( struct fd *fd, const async_data_t *async_data, int blocking, + file_pos_t pos, data_size_t *written ); static obj_handle_t device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data, int blocking ); @@ -156,8 +160,8 @@ static const struct fd_ops device_fd_ops = default_fd_get_poll_events, /* get_poll_events */ default_poll_event, /* poll_event */ device_get_fd_type, /* get_fd_type */ - no_fd_read, /* read */ - no_fd_write, /* write */ + device_read, /* read */ + device_write, /* write */ no_fd_flush, /* flush */ device_ioctl, /* ioctl */ default_fd_queue_async, /* queue_async */ @@ -199,6 +203,12 @@ static struct irp_call *create_irp( struct device *device, unsigned int type, co { struct irp_call *irp; + if (!device->manager) /* it has been deleted */ + { + set_error( STATUS_FILE_DELETED ); + return NULL; + } + if ((irp = alloc_object( &irp_call_ops ))) { irp->device = (struct device *)grab_object( device ); @@ -315,48 +325,79 @@ static struct irp_call *find_irp_call( struct device *device, struct thread *thr return NULL; } -static obj_handle_t device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data, - int blocking ) +/* queue an irp to the device */ +static obj_handle_t queue_irp( struct device *device, struct irp_call *irp, + const async_data_t *async_data, int blocking ) { - struct device *device = get_fd_user( fd ); - struct irp_call *irp; obj_handle_t handle = 0; - if (!device->manager) /* it has been deleted */ - { - set_error( STATUS_FILE_DELETED ); - return 0; - } - - if (!(irp = create_irp( device, IRP_MJ_DEVICE_CONTROL, get_req_data(), get_req_data_size(), - get_reply_max_size() ))) - return 0; - - irp->code = code; - irp->thread = (struct thread *)grab_object( current ); - irp->user_arg = async_data->arg; - - if (blocking && !(handle = alloc_handle( current->process, irp, SYNCHRONIZE, 0 ))) - { - release_object( irp ); - return 0; - } + if (blocking && !(handle = alloc_handle( current->process, irp, SYNCHRONIZE, 0 ))) return 0; if (!(irp->async = fd_queue_async( device->fd, async_data, ASYNC_TYPE_WAIT ))) { if (handle) close_handle( current->process, handle ); - release_object( irp ); return 0; } + irp->thread = (struct thread *)grab_object( current ); + irp->user_arg = async_data->arg; + grab_object( irp ); /* grab reference for queued irp */ + list_add_tail( &device->requests, &irp->dev_entry ); list_add_tail( &device->manager->requests, &irp->mgr_entry ); if (list_head( &device->manager->requests ) == &irp->mgr_entry) /* first one */ wake_up( &device->manager->obj, 0 ); - /* don't release irp since it is now queued in the device */ set_error( STATUS_PENDING ); return handle; } +static obj_handle_t device_read( struct fd *fd, const async_data_t *async_data, int blocking, + file_pos_t pos ) +{ + struct device *device = get_fd_user( fd ); + struct irp_call *irp; + obj_handle_t handle; + + irp = create_irp( device, IRP_MJ_READ, NULL, 0, get_reply_max_size() ); + if (!irp) return 0; + + handle = queue_irp( device, irp, async_data, blocking ); + release_object( irp ); + return handle; +} + +static obj_handle_t device_write( struct fd *fd, const async_data_t *async_data, int blocking, + file_pos_t pos, data_size_t *written ) +{ + struct device *device = get_fd_user( fd ); + struct irp_call *irp; + obj_handle_t handle; + + irp = create_irp( device, IRP_MJ_WRITE, get_req_data(), get_req_data_size(), 0 ); + if (!irp) return 0; + + handle = queue_irp( device, irp, async_data, blocking ); + release_object( irp ); + return handle; +} + +static obj_handle_t device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data, + int blocking ) +{ + struct device *device = get_fd_user( fd ); + struct irp_call *irp; + obj_handle_t handle; + + irp = create_irp( device, IRP_MJ_DEVICE_CONTROL, get_req_data(), get_req_data_size(), + get_reply_max_size() ); + if (!irp) return 0; + + irp->code = code; + + handle = queue_irp( device, irp, async_data, blocking ); + release_object( irp ); + return handle; +} + static struct device *create_device( struct directory *root, const struct unicode_str *name, struct device_manager *manager, unsigned int attr ) {

1 0

Alexandre Julliard : server: Add read and write requests on file objects.
by Alexandre Julliard 06 May '15

06 May '15

Module: wine Branch: master Commit: 41ea55294ed4d5735fd2e2c7be6510d85af11229 URL: http://source.winehq.org/git/wine.git/?a=commit;h=41ea55294ed4d5735fd2e2c7b… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Tue May 5 12:50:51 2015 +0900 server: Add read and write requests on file objects. --- include/wine/server_protocol.h | 44 +++++++++++++++++++++++++++++++++++++++++- server/fd.c | 26 +++++++++++++++++++++++++ server/protocol.def | 25 ++++++++++++++++++++++++ server/request.h | 19 ++++++++++++++++++ server/trace.c | 35 +++++++++++++++++++++++++++++++++ 5 files changed, 148 insertions(+), 1 deletion(-) diff --git a/include/wine/server_protocol.h b/include/wine/server_protocol.h index fabd3b4..b838f0b 100644 --- a/include/wine/server_protocol.h +++ b/include/wine/server_protocol.h @@ -3110,6 +3110,42 @@ struct cancel_async_reply +struct read_request +{ + struct request_header __header; + int blocking; + async_data_t async; + file_pos_t pos; +}; +struct read_reply +{ + struct reply_header __header; + obj_handle_t wait; + unsigned int options; + /* VARARG(data,bytes); */ +}; + + + +struct write_request +{ + struct request_header __header; + int blocking; + async_data_t async; + file_pos_t pos; + /* VARARG(data,bytes); */ +}; +struct write_reply +{ + struct reply_header __header; + obj_handle_t wait; + unsigned int options; + data_size_t size; + char __pad_20[4]; +}; + + + struct ioctl_request { struct request_header __header; @@ -5319,6 +5355,8 @@ enum request REQ_set_serial_info, REQ_register_async, REQ_cancel_async, + REQ_read, + REQ_write, REQ_ioctl, REQ_set_irp_result, REQ_get_irp_result, @@ -5588,6 +5626,8 @@ 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 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; @@ -5855,6 +5895,8 @@ 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 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; @@ -5978,6 +6020,6 @@ union generic_reply struct terminate_job_reply terminate_job_reply; }; -#define SERVER_PROTOCOL_VERSION 472 +#define SERVER_PROTOCOL_VERSION 473 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */ diff --git a/server/fd.c b/server/fd.c index c5340ff..e7f151a 100644 --- a/server/fd.c +++ b/server/fd.c @@ -2303,6 +2303,32 @@ DECL_HANDLER(get_handle_fd) } } +/* perform a read on a file object */ +DECL_HANDLER(read) +{ + struct fd *fd = get_handle_fd_obj( current->process, req->async.handle, FILE_READ_DATA ); + + if (fd) + { + reply->wait = fd->fd_ops->read( fd, &req->async, req->blocking, req->pos ); + reply->options = fd->options; + release_object( fd ); + } +} + +/* perform a write on a file object */ +DECL_HANDLER(write) +{ + struct fd *fd = get_handle_fd_obj( current->process, req->async.handle, FILE_WRITE_DATA ); + + if (fd) + { + reply->wait = fd->fd_ops->write( fd, &req->async, req->blocking, req->pos, &reply->size ); + reply->options = fd->options; + release_object( fd ); + } +} + /* perform an ioctl on a file */ DECL_HANDLER(ioctl) { diff --git a/server/protocol.def b/server/protocol.def index 3c03977..b2c417d 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -2250,6 +2250,31 @@ enum message_type @END +/* Perform a read on a file object */ +@REQ(read) + int blocking; /* whether it's a blocking read */ + async_data_t async; /* async I/O parameters */ + file_pos_t pos; /* read position */ +@REPLY + obj_handle_t wait; /* handle to wait on for blocking read */ + unsigned int options; /* device open options */ + VARARG(data,bytes); /* read data */ +@END + + +/* Perform a write on a file object */ +@REQ(write) + int blocking; /* whether it's a blocking write */ + async_data_t async; /* async I/O parameters */ + file_pos_t pos; /* write position */ + VARARG(data,bytes); /* write data */ +@REPLY + obj_handle_t wait; /* handle to wait on for blocking write */ + unsigned int options; /* device open options */ + data_size_t size; /* size written */ +@END + + /* Perform an ioctl on a file */ @REQ(ioctl) ioctl_code_t code; /* ioctl code */ diff --git a/server/request.h b/server/request.h index 9ed815e..6d43e9f 100644 --- a/server/request.h +++ b/server/request.h @@ -247,6 +247,8 @@ DECL_HANDLER(get_serial_info); DECL_HANDLER(set_serial_info); DECL_HANDLER(register_async); DECL_HANDLER(cancel_async); +DECL_HANDLER(read); +DECL_HANDLER(write); DECL_HANDLER(ioctl); DECL_HANDLER(set_irp_result); DECL_HANDLER(get_irp_result); @@ -515,6 +517,8 @@ 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_read, + (req_handler)req_write, (req_handler)req_ioctl, (req_handler)req_set_irp_result, (req_handler)req_get_irp_result, @@ -1521,6 +1525,21 @@ 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 read_request, blocking) == 12 ); +C_ASSERT( FIELD_OFFSET(struct read_request, async) == 16 ); +C_ASSERT( FIELD_OFFSET(struct read_request, pos) == 56 ); +C_ASSERT( sizeof(struct read_request) == 64 ); +C_ASSERT( FIELD_OFFSET(struct read_reply, wait) == 8 ); +C_ASSERT( FIELD_OFFSET(struct read_reply, options) == 12 ); +C_ASSERT( sizeof(struct read_reply) == 16 ); +C_ASSERT( FIELD_OFFSET(struct write_request, blocking) == 12 ); +C_ASSERT( FIELD_OFFSET(struct write_request, async) == 16 ); +C_ASSERT( FIELD_OFFSET(struct write_request, pos) == 56 ); +C_ASSERT( sizeof(struct write_request) == 64 ); +C_ASSERT( FIELD_OFFSET(struct write_reply, wait) == 8 ); +C_ASSERT( FIELD_OFFSET(struct write_reply, options) == 12 ); +C_ASSERT( FIELD_OFFSET(struct write_reply, size) == 16 ); +C_ASSERT( sizeof(struct write_reply) == 24 ); C_ASSERT( FIELD_OFFSET(struct ioctl_request, code) == 12 ); C_ASSERT( FIELD_OFFSET(struct ioctl_request, async) == 16 ); C_ASSERT( FIELD_OFFSET(struct ioctl_request, blocking) == 56 ); diff --git a/server/trace.c b/server/trace.c index 8d888d3..e8d19de 100644 --- a/server/trace.c +++ b/server/trace.c @@ -2726,6 +2726,35 @@ static void dump_cancel_async_request( const struct cancel_async_request *req ) fprintf( stderr, ", only_thread=%d", req->only_thread ); } +static void dump_read_request( const struct read_request *req ) +{ + fprintf( stderr, " blocking=%d", req->blocking ); + dump_async_data( ", async=", &req->async ); + dump_uint64( ", pos=", &req->pos ); +} + +static void dump_read_reply( const struct read_reply *req ) +{ + fprintf( stderr, " wait=%04x", req->wait ); + fprintf( stderr, ", options=%08x", req->options ); + dump_varargs_bytes( ", data=", cur_size ); +} + +static void dump_write_request( const struct write_request *req ) +{ + fprintf( stderr, " blocking=%d", req->blocking ); + dump_async_data( ", async=", &req->async ); + dump_uint64( ", pos=", &req->pos ); + dump_varargs_bytes( ", data=", cur_size ); +} + +static void dump_write_reply( const struct write_reply *req ) +{ + fprintf( stderr, " wait=%04x", req->wait ); + fprintf( stderr, ", options=%08x", req->options ); + fprintf( stderr, ", size=%u", req->size ); +} + static void dump_ioctl_request( const struct ioctl_request *req ) { dump_ioctl_code( " code=", &req->code ); @@ -4292,6 +4321,8 @@ 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_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, @@ -4557,6 +4588,8 @@ static const dump_func reply_dumpers[REQ_NB_REQUESTS] = { NULL, NULL, NULL, + (dump_func)dump_read_reply, + (dump_func)dump_write_reply, (dump_func)dump_ioctl_reply, NULL, (dump_func)dump_get_irp_result_reply, @@ -4822,6 +4855,8 @@ static const char * const req_names[REQ_NB_REQUESTS] = { "set_serial_info", "register_async", "cancel_async", + "read", + "write", "ioctl", "set_irp_result", "get_irp_result",

1 0

Alexandre Julliard : server: Add an async structure to the flush request to follow the common pattern.
by Alexandre Julliard 06 May '15

06 May '15

Module: wine Branch: master Commit: 860091d2fd7d5aa08e471af494d74bbc46d1806b URL: http://source.winehq.org/git/wine.git/?a=commit;h=860091d2fd7d5aa08e471af49… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Tue May 5 12:23:08 2015 +0900 server: Add an async structure to the flush request to follow the common pattern. --- dlls/ntdll/file.c | 12 ++++++++---- include/wine/server_protocol.h | 15 ++++++++------- server/fd.c | 14 +++++--------- server/file.c | 5 +++-- server/file.h | 4 ++-- server/named_pipe.c | 20 ++++++++++++-------- server/protocol.def | 5 +++-- server/request.h | 13 +++++++------ server/trace.c | 13 +++++++------ 9 files changed, 55 insertions(+), 46 deletions(-) Diff: http://source.winehq.org/git/wine.git/?a=commitdiff;h=860091d2fd7d5aa08e471…

1 0

Alexandre Julliard : server: Add read and write fd member functions.
by Alexandre Julliard 06 May '15

06 May '15

Module: wine Branch: master Commit: 837b39b20284a101d103af8e78af37473a83756b URL: http://source.winehq.org/git/wine.git/?a=commit;h=837b39b20284a101d103af8e7… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Tue May 5 12:17:45 2015 +0900 server: Add read and write fd member functions. Also rename no_flush() to no_fd_flush() for consistency. --- server/change.c | 4 +++- server/console.c | 4 +++- server/device.c | 4 +++- server/fd.c | 28 ++++++++++++++++++++++------ server/file.c | 4 +++- server/file.h | 13 ++++++++++--- server/mailslot.c | 12 +++++++++--- server/mapping.c | 4 +++- server/named_pipe.c | 12 +++++++++--- server/serial.c | 4 +++- server/sock.c | 10 +++++++--- 11 files changed, 75 insertions(+), 24 deletions(-) Diff: http://source.winehq.org/git/wine.git/?a=commitdiff;h=837b39b20284a101d103a…

1 0

Alexandre Julliard : server: Return irp size separately from the output data.
by Alexandre Julliard 06 May '15

06 May '15

Module: wine Branch: master Commit: fc4a94c0e2997771acfeba4c704239f34c4f43c5 URL: http://source.winehq.org/git/wine.git/?a=commit;h=fc4a94c0e2997771acfeba4c7… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Tue May 5 13:35:27 2015 +0900 server: Return irp size separately from the output data. --- dlls/ntoskrnl.exe/ntoskrnl.c | 7 +++++-- include/wine/server_protocol.h | 6 +++++- server/device.c | 14 +++++++++----- server/protocol.def | 2 ++ server/request.h | 6 ++++-- server/trace.c | 4 +++- 6 files changed, 28 insertions(+), 11 deletions(-) diff --git a/dlls/ntoskrnl.exe/ntoskrnl.c b/dlls/ntoskrnl.exe/ntoskrnl.c index fbea0f4..5443aa7 100644 --- a/dlls/ntoskrnl.exe/ntoskrnl.c +++ b/dlls/ntoskrnl.exe/ntoskrnl.c @@ -1028,8 +1028,11 @@ VOID WINAPI IoCompleteRequest( IRP *irp, UCHAR priority_boost ) req->manager = wine_server_obj_handle( manager ); req->handle = wine_server_obj_handle( handle ); req->status = irp->IoStatus.u.Status; - if (irp->IoStatus.u.Status >= 0 && out_buff) - wine_server_add_data( req, out_buff, irp->IoStatus.Information ); + if (irp->IoStatus.u.Status >= 0) + { + req->size = irp->IoStatus.Information; + if (out_buff) wine_server_add_data( req, out_buff, irp->IoStatus.Information ); + } wine_server_call( req ); } SERVER_END_REQ; diff --git a/include/wine/server_protocol.h b/include/wine/server_protocol.h index b09ca13..ef0d181 100644 --- a/include/wine/server_protocol.h +++ b/include/wine/server_protocol.h @@ -3134,7 +3134,9 @@ struct set_irp_result_request obj_handle_t manager; obj_handle_t handle; unsigned int status; + data_size_t size; /* VARARG(data,bytes); */ + char __pad_28[4]; }; struct set_irp_result_reply { @@ -3152,7 +3154,9 @@ struct get_irp_result_request struct get_irp_result_reply { struct reply_header __header; + data_size_t size; /* VARARG(out_data,bytes); */ + char __pad_12[4]; }; @@ -5973,6 +5977,6 @@ union generic_reply struct terminate_job_reply terminate_job_reply; }; -#define SERVER_PROTOCOL_VERSION 470 +#define SERVER_PROTOCOL_VERSION 471 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */ diff --git a/server/device.c b/server/device.c index f7fa970..aabff79 100644 --- a/server/device.c +++ b/server/device.c @@ -47,6 +47,7 @@ struct irp_call unsigned int type; /* request type (IRP_MJ_*) */ unsigned int status; /* resulting status (or STATUS_PENDING) */ ioctl_code_t code; /* ioctl code */ + data_size_t result; /* size of result (input or output depending on the type) */ data_size_t in_size; /* size of input data */ void *in_data; /* input data */ data_size_t out_size; /* size of output data */ @@ -203,6 +204,7 @@ static struct irp_call *create_irp( struct device *device, unsigned int type, co irp->type = type; irp->code = 0; irp->status = STATUS_PENDING; + irp->result = 0; irp->in_size = in_size; irp->in_data = NULL; irp->out_size = out_size; @@ -218,7 +220,7 @@ static struct irp_call *create_irp( struct device *device, unsigned int type, co } static void set_irp_result( struct irp_call *irp, unsigned int status, - const void *out_data, data_size_t out_size ) + const void *out_data, data_size_t out_size, data_size_t result ) { struct device *device = irp->device; @@ -226,6 +228,7 @@ static void set_irp_result( struct irp_call *irp, unsigned int status, /* FIXME: handle the STATUS_PENDING case */ irp->status = status; + irp->result = result; irp->out_size = min( irp->out_size, out_size ); if (irp->out_size && !(irp->out_data = memdup( out_data, irp->out_size ))) irp->out_size = 0; @@ -233,7 +236,7 @@ static void set_irp_result( struct irp_call *irp, unsigned int status, irp->device = NULL; if (irp->async) { - if (irp->out_size) status = STATUS_ALERTED; + if (result) status = STATUS_ALERTED; async_terminate( irp->async, status ); release_object( irp->async ); irp->async = NULL; @@ -385,7 +388,7 @@ static void delete_device( struct device *device ) LIST_FOR_EACH_ENTRY_SAFE( irp, next, &device->requests, struct irp_call, dev_entry ) { list_remove( &irp->mgr_entry ); - set_irp_result( irp, STATUS_FILE_DELETED, NULL, 0 ); + set_irp_result( irp, STATUS_FILE_DELETED, NULL, 0, 0 ); } unlink_named_object( &device->obj ); list_remove( &device->entry ); @@ -503,7 +506,7 @@ DECL_HANDLER(get_next_device_request) if ((irp = (struct irp_call *)get_handle_obj( current->process, req->prev, 0, &irp_call_ops ))) { - set_irp_result( irp, req->status, NULL, 0 ); + set_irp_result( irp, req->status, NULL, 0, 0 ); close_handle( current->process, req->prev ); /* avoid an extra round-trip for close */ release_object( irp ); } @@ -548,7 +551,7 @@ DECL_HANDLER(set_irp_result) if ((irp = (struct irp_call *)get_handle_obj( current->process, req->handle, 0, &irp_call_ops ))) { - set_irp_result( irp, req->status, get_req_data(), get_req_data_size() ); + set_irp_result( irp, req->status, get_req_data(), get_req_data_size(), req->size ); close_handle( current->process, req->handle ); /* avoid an extra round-trip for close */ release_object( irp ); } @@ -576,6 +579,7 @@ DECL_HANDLER(get_irp_result) irp->out_data = NULL; } } + reply->size = irp->result; set_error( irp->status ); list_remove( &irp->dev_entry ); release_object( irp ); /* no longer on the device queue */ diff --git a/server/protocol.def b/server/protocol.def index 7e4737a..51ad56b 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -2267,6 +2267,7 @@ enum message_type obj_handle_t manager; /* handle to the device manager */ obj_handle_t handle; /* handle to the irp */ unsigned int status; /* status of the irp */ + data_size_t size; /* result size (input or output depending on the operation) */ VARARG(data,bytes); /* output data of the irp */ @END @@ -2276,6 +2277,7 @@ enum message_type 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 diff --git a/server/request.h b/server/request.h index bce80a1..0a6096c 100644 --- a/server/request.h +++ b/server/request.h @@ -1530,11 +1530,13 @@ C_ASSERT( sizeof(struct ioctl_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, manager) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, handle) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, status) == 20 ); -C_ASSERT( sizeof(struct set_irp_result_request) == 24 ); +C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, size) == 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( sizeof(struct get_irp_result_reply) == 8 ); +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, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, options) == 20 ); diff --git a/server/trace.c b/server/trace.c index e9127b4..27180ed 100644 --- a/server/trace.c +++ b/server/trace.c @@ -2745,6 +2745,7 @@ static void dump_set_irp_result_request( const struct set_irp_result_request *re fprintf( stderr, " manager=%04x", req->manager ); fprintf( stderr, ", handle=%04x", req->handle ); fprintf( stderr, ", status=%08x", req->status ); + fprintf( stderr, ", size=%u", req->size ); dump_varargs_bytes( ", data=", cur_size ); } @@ -2756,7 +2757,8 @@ static void dump_get_irp_result_request( const struct get_irp_result_request *re static void dump_get_irp_result_reply( const struct get_irp_result_reply *req ) { - dump_varargs_bytes( " out_data=", cur_size ); + 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 )

1 0

Alexandre Julliard : server: Retrieve ioctl data directly from the request.
by Alexandre Julliard 06 May '15

06 May '15

Module: wine Branch: master Commit: 6f2ed23c160206ca71114b30eb43f72d6784ad9d URL: http://source.winehq.org/git/wine.git/?a=commit;h=6f2ed23c160206ca71114b30e… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Tue May 5 12:02:59 2015 +0900 server: Retrieve ioctl data directly from the request. --- server/device.c | 7 ++++--- server/fd.c | 9 +++------ server/file.h | 9 +++------ server/named_pipe.c | 19 ++++++++++--------- server/sock.c | 6 ++---- 5 files changed, 22 insertions(+), 28 deletions(-) diff --git a/server/device.c b/server/device.c index 7ca5ba5..f7fa970 100644 --- a/server/device.c +++ b/server/device.c @@ -128,7 +128,7 @@ static struct object *device_open_file( struct object *obj, unsigned int access, unsigned int sharing, unsigned int options ); static enum server_fd_type device_get_fd_type( struct fd *fd ); static obj_handle_t device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data, - int blocking, const void *data, data_size_t size ); + int blocking ); static const struct object_ops device_ops = { @@ -311,7 +311,7 @@ static struct irp_call *find_irp_call( struct device *device, struct thread *thr } static obj_handle_t device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data, - int blocking, const void *data, data_size_t size ) + int blocking ) { struct device *device = get_fd_user( fd ); struct irp_call *irp; @@ -323,7 +323,8 @@ static obj_handle_t device_ioctl( struct fd *fd, ioctl_code_t code, const async_ return 0; } - if (!(irp = create_irp( device, IRP_MJ_DEVICE_CONTROL, data, size, get_reply_max_size() ))) + if (!(irp = create_irp( device, IRP_MJ_DEVICE_CONTROL, get_req_data(), get_req_data_size(), + get_reply_max_size() ))) return 0; irp->code = code; diff --git a/server/fd.c b/server/fd.c index e3b722c..a36df10 100644 --- a/server/fd.c +++ b/server/fd.c @@ -2164,16 +2164,14 @@ static void unmount_device( struct fd *device_fd ) release_object( device ); } -obj_handle_t no_fd_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async, - int blocking, const void *data, data_size_t size ) +obj_handle_t no_fd_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async, int blocking ) { set_error( STATUS_OBJECT_TYPE_MISMATCH ); return 0; } /* default ioctl() routine */ -obj_handle_t default_fd_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async, - int blocking, const void *data, data_size_t size ) +obj_handle_t default_fd_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async, int blocking ) { switch(code) { @@ -2301,8 +2299,7 @@ DECL_HANDLER(ioctl) if (fd) { - reply->wait = fd->fd_ops->ioctl( fd, req->code, &req->async, req->blocking, - get_req_data(), get_req_data_size() ); + reply->wait = fd->fd_ops->ioctl( fd, req->code, &req->async, req->blocking ); reply->options = fd->options; release_object( fd ); } diff --git a/server/file.h b/server/file.h index 85e4257..a466354 100644 --- a/server/file.h +++ b/server/file.h @@ -42,8 +42,7 @@ struct fd_ops /* get file information */ enum server_fd_type (*get_fd_type)(struct fd *fd); /* perform an ioctl on the file */ - obj_handle_t (*ioctl)(struct fd *fd, ioctl_code_t code, const async_data_t *async, int blocking, - const void *data, data_size_t size); + obj_handle_t (*ioctl)(struct fd *fd, ioctl_code_t code, const async_data_t *async, int blocking ); /* queue an async operation */ void (*queue_async)(struct fd *, const async_data_t *data, int type, int count); /* selected events for async i/o need an update */ @@ -86,10 +85,8 @@ extern void default_poll_event( struct fd *fd, int event ); extern struct async *fd_queue_async( struct fd *fd, const async_data_t *data, int type ); extern void fd_async_wake_up( struct fd *fd, int type, unsigned int status ); extern void fd_reselect_async( struct fd *fd, struct async_queue *queue ); -extern obj_handle_t no_fd_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async, - int blocking, const void *data, data_size_t size ); -extern obj_handle_t default_fd_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async, - int blocking, const void *data, data_size_t size ); +extern obj_handle_t no_fd_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async, int blocking ); +extern obj_handle_t default_fd_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async, int blocking ); extern void no_fd_queue_async( struct fd *fd, const async_data_t *data, int type, int count ); extern void default_fd_queue_async( struct fd *fd, const async_data_t *data, int type, int count ); extern void default_fd_reselect_async( struct fd *fd, struct async_queue *queue ); diff --git a/server/named_pipe.c b/server/named_pipe.c index 706cce8..6d5fc5e 100644 --- a/server/named_pipe.c +++ b/server/named_pipe.c @@ -144,7 +144,7 @@ static void pipe_server_destroy( struct object *obj); static void pipe_server_flush( struct fd *fd, struct event **event ); static enum server_fd_type pipe_server_get_fd_type( struct fd *fd ); static obj_handle_t pipe_server_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async, - int blocking, const void *data, data_size_t size ); + int blocking ); static const struct object_ops pipe_server_ops = { @@ -227,8 +227,8 @@ static struct object *named_pipe_device_open_file( struct object *obj, unsigned unsigned int sharing, unsigned int options ); static void named_pipe_device_destroy( struct object *obj ); static enum server_fd_type named_pipe_device_get_fd_type( struct fd *fd ); -static obj_handle_t named_pipe_device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data, - int blocking, const void *data, data_size_t size ); +static obj_handle_t named_pipe_device_ioctl( struct fd *fd, ioctl_code_t code, + const async_data_t *async_data, int blocking ); static const struct object_ops named_pipe_device_ops = { @@ -591,7 +591,7 @@ static enum server_fd_type pipe_client_get_fd_type( struct fd *fd ) } static obj_handle_t pipe_server_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data, - int blocking, const void *data, data_size_t size ) + int blocking ) { struct pipe_server *server = get_fd_user( fd ); struct async *async; @@ -672,7 +672,7 @@ static obj_handle_t pipe_server_ioctl( struct fd *fd, ioctl_code_t code, const a return 0; default: - return default_fd_ioctl( fd, code, async_data, blocking, data, size ); + return default_fd_ioctl( fd, code, async_data, blocking ); } } @@ -868,8 +868,8 @@ static struct object *named_pipe_open_file( struct object *obj, unsigned int acc return &client->obj; } -static obj_handle_t named_pipe_device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data, - int blocking, const void *data, data_size_t size ) +static obj_handle_t named_pipe_device_ioctl( struct fd *fd, ioctl_code_t code, + const async_data_t *async_data, int blocking ) { struct named_pipe_device *device = get_fd_user( fd ); @@ -877,7 +877,8 @@ static obj_handle_t named_pipe_device_ioctl( struct fd *fd, ioctl_code_t code, c { case FSCTL_PIPE_WAIT: { - const FILE_PIPE_WAIT_FOR_BUFFER *buffer = data; + const FILE_PIPE_WAIT_FOR_BUFFER *buffer = get_req_data(); + data_size_t size = get_req_data_size(); obj_handle_t wait_handle = 0; struct named_pipe *pipe; struct pipe_server *server; @@ -931,7 +932,7 @@ static obj_handle_t named_pipe_device_ioctl( struct fd *fd, ioctl_code_t code, c } default: - return default_fd_ioctl( fd, code, async_data, blocking, data, size ); + return default_fd_ioctl( fd, code, async_data, blocking ); } } diff --git a/server/sock.c b/server/sock.c index 823c846..ad0ec71 100644 --- a/server/sock.c +++ b/server/sock.c @@ -130,8 +130,7 @@ static void sock_destroy_ifchange_q( struct sock *sock ); static int sock_get_poll_events( struct fd *fd ); static void sock_poll_event( struct fd *fd, int event ); static enum server_fd_type sock_get_fd_type( struct fd *fd ); -static obj_handle_t sock_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async, - int blocking, const void *data, data_size_t size ); +static obj_handle_t sock_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async, int blocking ); static void sock_queue_async( struct fd *fd, const async_data_t *data, int type, int count ); static void sock_reselect_async( struct fd *fd, struct async_queue *queue ); static void sock_cancel_async( struct fd *fd, struct process *process, struct thread *thread, client_ptr_t iosb ); @@ -534,8 +533,7 @@ static enum server_fd_type sock_get_fd_type( struct fd *fd ) return FD_TYPE_SOCKET; } -obj_handle_t sock_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data, - int blocking, const void *data, data_size_t size ) +obj_handle_t sock_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data, int blocking ) { struct sock *sock = get_fd_user( fd ); obj_handle_t wait_handle = 0;

1 0

Alexandre Julliard : server: Rename ioctl to irp to allow supporting various types of I/O requests.
by Alexandre Julliard 06 May '15

06 May '15

Module: wine Branch: master Commit: 165dd1ff361817f1ba744eba2af786cc5ee2b602 URL: http://source.winehq.org/git/wine.git/?a=commit;h=165dd1ff361817f1ba744eba2… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Tue May 5 11:34:15 2015 +0900 server: Rename ioctl to irp to allow supporting various types of I/O requests. --- dlls/ntdll/file.c | 2 +- dlls/ntoskrnl.exe/ntoskrnl.c | 34 ++++-- include/wine/server_protocol.h | 27 ++--- server/device.c | 258 +++++++++++++++++++++-------------------- server/protocol.def | 34 +++--- server/request.h | 37 +++--- server/trace.c | 20 ++-- 7 files changed, 214 insertions(+), 198 deletions(-) Diff: http://source.winehq.org/git/wine.git/?a=commitdiff;h=165dd1ff361817f1ba744…

1 0

André Hentschel : server: Allow 32-bit connections on ARM64.
by Alexandre Julliard 06 May '15

06 May '15

Module: wine Branch: master Commit: 6adcad498c6c68aaff1bd3bd1c97880717a09a71 URL: http://source.winehq.org/git/wine.git/?a=commit;h=6adcad498c6c68aaff1bd3bd1… Author: André Hentschel <nerv(a)dawncrow.de> Date: Tue May 5 23:50:36 2015 +0200 server: Allow 32-bit connections on ARM64. --- server/process.h | 2 +- server/thread.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/server/process.h b/server/process.h index 59625f0..fa7f60d 100644 --- a/server/process.h +++ b/server/process.h @@ -107,7 +107,7 @@ struct process_snapshot }; #define CPU_FLAG(cpu) (1 << (cpu)) -#define CPU_64BIT_MASK CPU_FLAG(CPU_x86_64) +#define CPU_64BIT_MASK (CPU_FLAG(CPU_x86_64) | CPU_FLAG(CPU_ARM64)) /* process functions */ diff --git a/server/thread.c b/server/thread.c index 906b79d..6c5d12d 100644 --- a/server/thread.c +++ b/server/thread.c @@ -62,7 +62,7 @@ static const unsigned int supported_cpus = CPU_FLAG(CPU_POWERPC); #elif defined(__arm__) static const unsigned int supported_cpus = CPU_FLAG(CPU_ARM); #elif defined(__aarch64__) -static const unsigned int supported_cpus = CPU_FLAG(CPU_ARM64); +static const unsigned int supported_cpus = CPU_FLAG(CPU_ARM64) | CPU_FLAG(CPU_ARM); #else #error Unsupported CPU #endif

1 0

André Hentschel : winedump: Add ARM64 string.
by Alexandre Julliard 06 May '15

06 May '15

Module: wine Branch: master Commit: e5bc217e05d46cf96e99906857ba4c80726d2226 URL: http://source.winehq.org/git/wine.git/?a=commit;h=e5bc217e05d46cf96e9990685… Author: André Hentschel <nerv(a)dawncrow.de> Date: Tue May 5 23:50:33 2015 +0200 winedump: Add ARM64 string. --- tools/winedump/pe.c | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/winedump/pe.c b/tools/winedump/pe.c index aedd98e..51ceba4 100644 --- a/tools/winedump/pe.c +++ b/tools/winedump/pe.c @@ -61,6 +61,7 @@ const char *get_machine_str(int mach) case IMAGE_FILE_MACHINE_POWERPC: return "PowerPC"; case IMAGE_FILE_MACHINE_AMD64: return "AMD64"; case IMAGE_FILE_MACHINE_IA64: return "IA64"; + case IMAGE_FILE_MACHINE_ARM64: return "ARM64"; case IMAGE_FILE_MACHINE_ARM: return "ARM"; case IMAGE_FILE_MACHINE_ARMNT: return "ARMNT"; case IMAGE_FILE_MACHINE_THUMB: return "ARM Thumb";

1 0

← Newer
1
...
32
33
34
35
36
37
38
...
43
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-commits May 2015