May 2015 - Wine-Commits - list.winehq.org

Alexandre Julliard : server: Add a trace for the supported socket ioctl.
by Alexandre Julliard May 6, 2015

May 6, 2015

Module: wine Branch: master Commit: 62802339a5506e72a4c72911cd8205ecf4956224 URL: http://source.winehq.org/git/wine.git/?a=commit;h=62802339a5506e72a4c72911c… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Wed May 6 09:26:14 2015 +0900 server: Add a trace for the supported socket ioctl. --- server/trace.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/server/trace.c b/server/trace.c index 61c0c9f..e257afb 100644 --- a/server/trace.c +++ b/server/trace.c @@ -39,6 +39,8 @@ #include "winuser.h" #include "winioctl.h" #include "ddk/wdm.h" +#define USE_WS_PREFIX +#include "winsock2.h" #include "file.h" #include "request.h" #include "unicode.h" @@ -115,6 +117,7 @@ static void dump_ioctl_code( const char *prefix, const ioctl_code_t *code ) CASE(FSCTL_PIPE_DISCONNECT); CASE(FSCTL_PIPE_LISTEN); CASE(FSCTL_PIPE_WAIT); + CASE(WS_SIO_ADDRESS_LIST_CHANGE); default: fprintf( stderr, "%s%08x", prefix, *code ); break; #undef CASE }

1 0

Alexandre Julliard : server: Implement read and write requests for device files.
by Alexandre Julliard May 6, 2015

May 6, 2015

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 May 6, 2015

May 6, 2015

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 */ +(a)REQ(read) + int blocking; /* whether it's a blocking read */ + async_data_t async; /* async I/O parameters */ + file_pos_t pos; /* read position */ +(a)REPLY + obj_handle_t wait; /* handle to wait on for blocking read */ + unsigned int options; /* device open options */ + VARARG(data,bytes); /* read data */ +(a)END + + +/* Perform a write on a file object */ +(a)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 */ +(a)REPLY + obj_handle_t wait; /* handle to wait on for blocking write */ + unsigned int options; /* device open options */ + data_size_t size; /* size written */ +(a)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 May 6, 2015

May 6, 2015

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: Return irp size separately from the output data.
by Alexandre Julliard May 6, 2015

May 6, 2015

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 : ntoskrnl: Add support for flush requests.
by Alexandre Julliard May 6, 2015

May 6, 2015

Module: wine Branch: master Commit: a38aaf4365ac37de5112821bc90e84684b842919 URL: http://source.winehq.org/git/wine.git/?a=commit;h=a38aaf4365ac37de5112821bc… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Wed May 6 17:14:31 2015 +0900 ntoskrnl: Add support for flush requests. --- dlls/ntoskrnl.exe/ntoskrnl.c | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/dlls/ntoskrnl.exe/ntoskrnl.c b/dlls/ntoskrnl.exe/ntoskrnl.c index de99970..2051939 100644 --- a/dlls/ntoskrnl.exe/ntoskrnl.c +++ b/dlls/ntoskrnl.exe/ntoskrnl.c @@ -203,6 +203,22 @@ static NTSTATUS dispatch_write( DEVICE_OBJECT *device, const irp_params_t *param return dispatch_irp( device, irp ); } +/* process a flush request for a given device */ +static NTSTATUS dispatch_flush( DEVICE_OBJECT *device, const irp_params_t *params, + void *in_buff, ULONG in_size, ULONG out_size, HANDLE irp_handle ) +{ + IRP *irp; + + TRACE( "device %p\n", device ); + + /* note: we abuse UserIosb to store the server irp handle */ + if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_FLUSH_BUFFERS, device, in_buff, in_size, + NULL, NULL, irp_handle ))) + return STATUS_NO_MEMORY; + + return dispatch_irp( device, irp ); +} + /* process an ioctl request for a given device */ static NTSTATUS dispatch_ioctl( DEVICE_OBJECT *device, const irp_params_t *params, void *in_buff, ULONG in_size, ULONG out_size, HANDLE irp_handle ) @@ -249,7 +265,7 @@ static const dispatch_func dispatch_funcs[IRP_MJ_MAXIMUM_FUNCTION + 1] = NULL, /* IRP_MJ_SET_INFORMATION */ NULL, /* IRP_MJ_QUERY_EA */ NULL, /* IRP_MJ_SET_EA */ - NULL, /* IRP_MJ_FLUSH_BUFFERS */ + dispatch_flush, /* IRP_MJ_FLUSH_BUFFERS */ NULL, /* IRP_MJ_QUERY_VOLUME_INFORMATION */ NULL, /* IRP_MJ_SET_VOLUME_INFORMATION */ NULL, /* IRP_MJ_DIRECTORY_CONTROL */

1 0

Alexandre Julliard : server: Implement flush requests for device files.
by Alexandre Julliard May 6, 2015

May 6, 2015

Module: wine Branch: master Commit: 6073e75a6a4b0dbb1a9ff74c01f373d1af80a5e6 URL: http://source.winehq.org/git/wine.git/?a=commit;h=6073e75a6a4b0dbb1a9ff74c0… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Wed May 6 17:13:51 2015 +0900 server: Implement flush requests for device files. --- server/device.c | 20 +++++++++++++++++++- server/trace.c | 3 +++ 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/server/device.c b/server/device.c index 2707faf..a2fc1cb 100644 --- a/server/device.c +++ b/server/device.c @@ -131,6 +131,7 @@ static obj_handle_t device_read( struct fd *fd, const async_data_t *async_data, 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_flush( struct fd *fd, const async_data_t *async_data, int blocking ); static obj_handle_t device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data, int blocking ); @@ -161,7 +162,7 @@ static const struct fd_ops device_fd_ops = device_get_fd_type, /* get_fd_type */ device_read, /* read */ device_write, /* write */ - no_fd_flush, /* flush */ + device_flush, /* flush */ device_ioctl, /* ioctl */ default_fd_queue_async, /* queue_async */ default_fd_reselect_async, /* reselect_async */ @@ -388,6 +389,23 @@ static obj_handle_t device_write( struct fd *fd, const async_data_t *async_data, return handle; } +static obj_handle_t device_flush( struct fd *fd, const async_data_t *async_data, int blocking ) +{ + struct device *device = get_fd_user( fd ); + struct irp_call *irp; + obj_handle_t handle; + irp_params_t params; + + params.major = IRP_MJ_FLUSH_BUFFERS; + + irp = create_irp( device, &params, NULL, 0, 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 ) { diff --git a/server/trace.c b/server/trace.c index e257afb..e4b6af5 100644 --- a/server/trace.c +++ b/server/trace.c @@ -326,6 +326,9 @@ static void dump_irp_params( const char *prefix, const irp_params_t *data ) dump_uint64( ",pos=", &data->write.pos ); fputc( '}', stderr ); break; + case IRP_MJ_FLUSH_BUFFERS: + fprintf( stderr, "%s{major=FLUSH_BUFFERS}", prefix ); + break; case IRP_MJ_DEVICE_CONTROL: fprintf( stderr, "%s{major=DEVICE_CONTROL", prefix ); dump_ioctl_code( ",code=", &data->ioctl.code );

1 0

Alexandre Julliard : server: Allow cancelling async I/ O for all object types.
by Alexandre Julliard May 6, 2015

May 6, 2015

Module: wine Branch: master Commit: 83e3a9c9ba6efa583a0d7b641409c9a457fa8bfe URL: http://source.winehq.org/git/wine.git/?a=commit;h=83e3a9c9ba6efa583a0d7b641… Author: Alexandre Julliard <julliard(a)winehq.org> Date: Wed May 6 13:48:05 2015 +0900 server: Allow cancelling async I/O for all object types. --- server/fd.c | 8 ++++---- server/file.h | 4 ++-- server/sock.c | 9 +++++---- 3 files changed, 11 insertions(+), 10 deletions(-) diff --git a/server/fd.c b/server/fd.c index e7f151a..1253b3d 100644 --- a/server/fd.c +++ b/server/fd.c @@ -2100,15 +2100,14 @@ void default_fd_reselect_async( struct fd *fd, struct async_queue *queue ) } /* default cancel_async() fd routine */ -void default_fd_cancel_async( struct fd *fd, struct process *process, struct thread *thread, client_ptr_t iosb ) +int default_fd_cancel_async( struct fd *fd, struct process *process, struct thread *thread, client_ptr_t iosb ) { int n = 0; n += async_wake_up_by( fd->read_q, process, thread, iosb, STATUS_CANCELLED ); n += async_wake_up_by( fd->write_q, process, thread, iosb, STATUS_CANCELLED ); n += async_wake_up_by( fd->wait_q, process, thread, iosb, STATUS_CANCELLED ); - if (!n && iosb) - set_error( STATUS_NOT_FOUND ); + return n; } static inline int is_valid_mounted_device( struct stat *st ) @@ -2377,7 +2376,8 @@ DECL_HANDLER(cancel_async) if (fd) { - if (get_unix_fd( fd ) != -1) fd->fd_ops->cancel_async( fd, current->process, thread, req->iosb ); + int count = fd->fd_ops->cancel_async( fd, current->process, thread, req->iosb ); + if (!count && req->iosb) set_error( STATUS_NOT_FOUND ); release_object( fd ); } } diff --git a/server/file.h b/server/file.h index 7e8b12e..603b686 100644 --- a/server/file.h +++ b/server/file.h @@ -52,7 +52,7 @@ struct fd_ops /* selected events for async i/o need an update */ void (*reselect_async)( struct fd *, struct async_queue *queue ); /* cancel an async operation */ - void (*cancel_async)(struct fd *, struct process *process, struct thread *thread, client_ptr_t iosb); + int (*cancel_async)(struct fd *, struct process *process, struct thread *thread, client_ptr_t iosb); }; /* file descriptor functions */ @@ -98,7 +98,7 @@ extern obj_handle_t default_fd_ioctl( struct fd *fd, ioctl_code_t code, const as 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 ); -extern void default_fd_cancel_async( struct fd *fd, struct process *process, struct thread *thread, client_ptr_t iosb ); +extern int default_fd_cancel_async( struct fd *fd, struct process *process, struct thread *thread, client_ptr_t iosb ); extern void main_loop(void); extern void remove_process_locks( struct process *process ); diff --git a/server/sock.c b/server/sock.c index 337006f..c4dcf6f 100644 --- a/server/sock.c +++ b/server/sock.c @@ -133,7 +133,7 @@ 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 ); 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 ); +static int sock_cancel_async( struct fd *fd, struct process *process, struct thread *thread, client_ptr_t iosb ); static int sock_get_ntstatus( int err ); static int sock_get_error( int err ); @@ -609,16 +609,17 @@ static void sock_reselect_async( struct fd *fd, struct async_queue *queue ) sock_reselect( sock ); } -static void sock_cancel_async( struct fd *fd, struct process *process, struct thread *thread, client_ptr_t iosb ) +static int sock_cancel_async( struct fd *fd, struct process *process, struct thread *thread, client_ptr_t iosb ) { struct sock *sock = get_fd_user( fd ); int n = 0; + assert( sock->obj.ops == &sock_ops ); n += async_wake_up_by( sock->read_q, process, thread, iosb, STATUS_CANCELLED ); n += async_wake_up_by( sock->write_q, process, thread, iosb, STATUS_CANCELLED ); - if (!n && iosb) - set_error( STATUS_NOT_FOUND ); + n += async_wake_up_by( sock->ifchange_q, process, thread, iosb, STATUS_CANCELLED ); + return n; } static struct fd *sock_get_fd( struct object *obj )

1 0

Alexandre Julliard : server: Rename ioctl to irp to allow supporting various types of I/O requests.
by Alexandre Julliard May 6, 2015

May 6, 2015

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 : winedump: Add ARM64 string.
by Alexandre Julliard May 6, 2015

May 6, 2015

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