server: Initialize irp->thread immediately after creation of irp_call object.
[wine/multimedia.git] / server / device.c
blob812bce3506ce72332bbfc1156fb932e0b67cdb83
1 /*
2 * Server-side device support
4 * Copyright (C) 2007 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #include "config.h"
22 #include "wine/port.h"
24 #include <assert.h>
25 #include <fcntl.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <stdarg.h>
30 #include "ntstatus.h"
31 #define WIN32_NO_STATUS
32 #include "windef.h"
33 #include "winternl.h"
34 #include "ddk/wdm.h"
36 #include "object.h"
37 #include "file.h"
38 #include "handle.h"
39 #include "request.h"
40 #include "process.h"
42 /* IRP object */
44 struct irp_call
46 struct object obj; /* object header */
47 struct list dev_entry; /* entry in device queue */
48 struct list mgr_entry; /* entry in manager queue */
49 struct device_file *file; /* file containing this irp */
50 struct thread *thread; /* thread that queued the irp */
51 client_ptr_t user_arg; /* user arg used to identify the request */
52 struct async *async; /* pending async op */
53 unsigned int status; /* resulting status (or STATUS_PENDING) */
54 irp_params_t params; /* irp parameters */
55 data_size_t result; /* size of result (input or output depending on the type) */
56 data_size_t in_size; /* size of input data */
57 void *in_data; /* input data */
58 data_size_t out_size; /* size of output data */
59 void *out_data; /* output data */
62 static void irp_call_dump( struct object *obj, int verbose );
63 static int irp_call_signaled( struct object *obj, struct wait_queue_entry *entry );
64 static void irp_call_destroy( struct object *obj );
66 static const struct object_ops irp_call_ops =
68 sizeof(struct irp_call), /* size */
69 irp_call_dump, /* dump */
70 no_get_type, /* get_type */
71 add_queue, /* add_queue */
72 remove_queue, /* remove_queue */
73 irp_call_signaled, /* signaled */
74 no_satisfied, /* satisfied */
75 no_signal, /* signal */
76 no_get_fd, /* get_fd */
77 no_map_access, /* map_access */
78 default_get_sd, /* get_sd */
79 default_set_sd, /* set_sd */
80 no_lookup_name, /* lookup_name */
81 no_open_file, /* open_file */
82 no_close_handle, /* close_handle */
83 irp_call_destroy /* destroy */
87 /* device manager (a list of devices managed by the same client process) */
89 struct device_manager
91 struct object obj; /* object header */
92 struct list devices; /* list of devices */
93 struct list requests; /* list of pending irps across all devices */
96 static void device_manager_dump( struct object *obj, int verbose );
97 static int device_manager_signaled( struct object *obj, struct wait_queue_entry *entry );
98 static void device_manager_destroy( struct object *obj );
100 static const struct object_ops device_manager_ops =
102 sizeof(struct device_manager), /* size */
103 device_manager_dump, /* dump */
104 no_get_type, /* get_type */
105 add_queue, /* add_queue */
106 remove_queue, /* remove_queue */
107 device_manager_signaled, /* signaled */
108 no_satisfied, /* satisfied */
109 no_signal, /* signal */
110 no_get_fd, /* get_fd */
111 no_map_access, /* map_access */
112 default_get_sd, /* get_sd */
113 default_set_sd, /* set_sd */
114 no_lookup_name, /* lookup_name */
115 no_open_file, /* open_file */
116 no_close_handle, /* close_handle */
117 device_manager_destroy /* destroy */
121 /* device (a single device object) */
123 struct device
125 struct object obj; /* object header */
126 struct device_manager *manager; /* manager for this device (or NULL if deleted) */
127 char *unix_path; /* path to unix device if any */
128 client_ptr_t user_ptr; /* opaque ptr for client side */
129 struct list entry; /* entry in device manager list */
130 struct list files; /* list of open files */
133 static void device_dump( struct object *obj, int verbose );
134 static struct object_type *device_get_type( struct object *obj );
135 static void device_destroy( struct object *obj );
136 static struct object *device_open_file( struct object *obj, unsigned int access,
137 unsigned int sharing, unsigned int options );
139 static const struct object_ops device_ops =
141 sizeof(struct device), /* size */
142 device_dump, /* dump */
143 device_get_type, /* get_type */
144 no_add_queue, /* add_queue */
145 NULL, /* remove_queue */
146 NULL, /* signaled */
147 no_satisfied, /* satisfied */
148 no_signal, /* signal */
149 no_get_fd, /* get_fd */
150 default_fd_map_access, /* map_access */
151 default_get_sd, /* get_sd */
152 default_set_sd, /* set_sd */
153 no_lookup_name, /* lookup_name */
154 device_open_file, /* open_file */
155 no_close_handle, /* close_handle */
156 device_destroy /* destroy */
160 /* device file (an open file handle to a device) */
162 struct device_file
164 struct object obj; /* object header */
165 struct device *device; /* device for this file */
166 struct fd *fd; /* file descriptor for irp */
167 client_ptr_t user_ptr; /* opaque ptr for client side */
168 struct list entry; /* entry in device list */
169 struct list requests; /* list of pending irp requests */
172 static void device_file_dump( struct object *obj, int verbose );
173 static struct fd *device_file_get_fd( struct object *obj );
174 static int device_file_close_handle( struct object *obj, struct process *process, obj_handle_t handle );
175 static void device_file_destroy( struct object *obj );
176 static enum server_fd_type device_file_get_fd_type( struct fd *fd );
177 static obj_handle_t device_file_read( struct fd *fd, const async_data_t *async_data, int blocking,
178 file_pos_t pos );
179 static obj_handle_t device_file_write( struct fd *fd, const async_data_t *async_data, int blocking,
180 file_pos_t pos, data_size_t *written );
181 static obj_handle_t device_file_flush( struct fd *fd, const async_data_t *async_data, int blocking );
182 static obj_handle_t device_file_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data,
183 int blocking );
185 static const struct object_ops device_file_ops =
187 sizeof(struct device_file), /* size */
188 device_file_dump, /* dump */
189 no_get_type, /* get_type */
190 add_queue, /* add_queue */
191 remove_queue, /* remove_queue */
192 default_fd_signaled, /* signaled */
193 no_satisfied, /* satisfied */
194 no_signal, /* signal */
195 device_file_get_fd, /* get_fd */
196 default_fd_map_access, /* map_access */
197 default_get_sd, /* get_sd */
198 default_set_sd, /* set_sd */
199 no_lookup_name, /* lookup_name */
200 no_open_file, /* open_file */
201 device_file_close_handle, /* close_handle */
202 device_file_destroy /* destroy */
205 static const struct fd_ops device_file_fd_ops =
207 default_fd_get_poll_events, /* get_poll_events */
208 default_poll_event, /* poll_event */
209 device_file_get_fd_type, /* get_fd_type */
210 device_file_read, /* read */
211 device_file_write, /* write */
212 device_file_flush, /* flush */
213 device_file_ioctl, /* ioctl */
214 default_fd_queue_async, /* queue_async */
215 default_fd_reselect_async, /* reselect_async */
216 default_fd_cancel_async /* cancel_async */
220 static void irp_call_dump( struct object *obj, int verbose )
222 struct irp_call *irp = (struct irp_call *)obj;
223 fprintf( stderr, "IRP call file=%p\n", irp->file );
226 static int irp_call_signaled( struct object *obj, struct wait_queue_entry *entry )
228 struct irp_call *irp = (struct irp_call *)obj;
230 return !irp->file; /* file is cleared once the irp has completed */
233 static void irp_call_destroy( struct object *obj )
235 struct irp_call *irp = (struct irp_call *)obj;
237 free( irp->in_data );
238 free( irp->out_data );
239 if (irp->async)
241 async_terminate( irp->async, STATUS_CANCELLED );
242 release_object( irp->async );
244 if (irp->file) release_object( irp->file );
245 if (irp->thread) release_object( irp->thread );
248 static struct irp_call *create_irp( struct device_file *file, const irp_params_t *params,
249 const void *in_data, data_size_t in_size, data_size_t out_size )
251 struct irp_call *irp;
253 if (!file->device->manager) /* it has been deleted */
255 set_error( STATUS_FILE_DELETED );
256 return NULL;
259 if ((irp = alloc_object( &irp_call_ops )))
261 irp->file = (struct device_file *)grab_object( file );
262 irp->thread = NULL;
263 irp->async = NULL;
264 irp->params = *params;
265 irp->status = STATUS_PENDING;
266 irp->result = 0;
267 irp->in_size = in_size;
268 irp->in_data = NULL;
269 irp->out_size = out_size;
270 irp->out_data = NULL;
272 if (irp->in_size && !(irp->in_data = memdup( in_data, in_size )))
274 release_object( irp );
275 irp = NULL;
278 return irp;
281 static void set_irp_result( struct irp_call *irp, unsigned int status,
282 const void *out_data, data_size_t out_size, data_size_t result )
284 struct device_file *file = irp->file;
286 if (!file) return; /* already finished */
288 /* FIXME: handle the STATUS_PENDING case */
289 irp->status = status;
290 irp->result = result;
291 irp->out_size = min( irp->out_size, out_size );
292 if (irp->out_size && !(irp->out_data = memdup( out_data, irp->out_size )))
293 irp->out_size = 0;
294 irp->file = NULL;
295 if (irp->async)
297 if (result) status = STATUS_ALERTED;
298 async_terminate( irp->async, status );
299 release_object( irp->async );
300 irp->async = NULL;
302 wake_up( &irp->obj, 0 );
304 if (status != STATUS_ALERTED)
306 /* remove it from the device queue */
307 /* (for STATUS_ALERTED this will be done in get_irp_result) */
308 list_remove( &irp->dev_entry );
309 release_object( irp ); /* no longer on the device queue */
311 release_object( file );
315 static void device_dump( struct object *obj, int verbose )
317 struct device *device = (struct device *)obj;
319 fprintf( stderr, "Device " );
320 dump_object_name( &device->obj );
321 fputc( '\n', stderr );
324 static struct object_type *device_get_type( struct object *obj )
326 static const WCHAR name[] = {'D','e','v','i','c','e'};
327 static const struct unicode_str str = { name, sizeof(name) };
328 return get_object_type( &str );
331 static void device_destroy( struct object *obj )
333 struct device *device = (struct device *)obj;
335 assert( list_empty( &device->files ));
337 free( device->unix_path );
338 if (device->manager) list_remove( &device->entry );
341 static void add_irp_to_queue( struct device_file *file, struct irp_call *irp, struct thread *thread )
343 struct device_manager *manager = file->device->manager;
345 assert( manager );
347 grab_object( irp ); /* grab reference for queued irp */
348 irp->thread = thread ? (struct thread *)grab_object( thread ) : NULL;
349 list_add_tail( &file->requests, &irp->dev_entry );
350 list_add_tail( &manager->requests, &irp->mgr_entry );
351 if (list_head( &manager->requests ) == &irp->mgr_entry) wake_up( &manager->obj, 0 ); /* first one */
354 static struct object *device_open_file( struct object *obj, unsigned int access,
355 unsigned int sharing, unsigned int options )
357 struct device *device = (struct device *)obj;
358 struct device_file *file;
360 if (!(file = alloc_object( &device_file_ops ))) return NULL;
362 file->device = (struct device *)grab_object( device );
363 file->user_ptr = 0;
364 list_init( &file->requests );
365 list_add_tail( &device->files, &file->entry );
366 if (device->unix_path)
368 mode_t mode = 0666;
369 access = file->obj.ops->map_access( &file->obj, access );
370 file->fd = open_fd( NULL, device->unix_path, O_NONBLOCK | O_LARGEFILE,
371 &mode, access, sharing, options );
372 if (file->fd) set_fd_user( file->fd, &device_file_fd_ops, &file->obj );
374 else file->fd = alloc_pseudo_fd( &device_file_fd_ops, &file->obj, 0 );
376 if (!file->fd)
378 release_object( file );
379 return NULL;
382 if (device->manager)
384 struct irp_call *irp;
385 irp_params_t params;
387 params.create.major = IRP_MJ_CREATE;
388 params.create.access = access;
389 params.create.sharing = sharing;
390 params.create.options = options;
391 params.create.device = file->device->user_ptr;
393 if ((irp = create_irp( file, &params, NULL, 0, 0 )))
395 add_irp_to_queue( file, irp, NULL );
396 release_object( irp );
399 return &file->obj;
402 static void device_file_dump( struct object *obj, int verbose )
404 struct device_file *file = (struct device_file *)obj;
406 fprintf( stderr, "File on device %p\n", file->device );
409 static struct fd *device_file_get_fd( struct object *obj )
411 struct device_file *file = (struct device_file *)obj;
413 return (struct fd *)grab_object( file->fd );
416 static int device_file_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
418 struct device_file *file = (struct device_file *)obj;
420 if (file->device->manager && obj->handle_count == 1) /* last handle */
422 struct irp_call *irp;
423 irp_params_t params;
425 params.close.major = IRP_MJ_CLOSE;
426 params.close.file = file->user_ptr;
428 if ((irp = create_irp( file, &params, NULL, 0, 0 )))
430 add_irp_to_queue( file, irp, NULL );
431 release_object( irp );
434 return 1;
437 static void device_file_destroy( struct object *obj )
439 struct device_file *file = (struct device_file *)obj;
440 struct irp_call *irp, *next;
442 LIST_FOR_EACH_ENTRY_SAFE( irp, next, &file->requests, struct irp_call, dev_entry )
444 list_remove( &irp->dev_entry );
445 release_object( irp ); /* no longer on the device queue */
447 if (file->fd) release_object( file->fd );
448 list_remove( &file->entry );
449 release_object( file->device );
452 static struct irp_call *find_irp_call( struct device_file *file, struct thread *thread,
453 client_ptr_t user_arg )
455 struct irp_call *irp;
457 LIST_FOR_EACH_ENTRY( irp, &file->requests, struct irp_call, dev_entry )
458 if (irp->thread == thread && irp->user_arg == user_arg) return irp;
460 set_error( STATUS_INVALID_PARAMETER );
461 return NULL;
464 static void set_file_user_ptr( struct device_file *file, client_ptr_t ptr )
466 struct irp_call *irp;
468 if (file->user_ptr == ptr) return; /* nothing to do */
470 file->user_ptr = ptr;
472 /* update already queued irps */
474 LIST_FOR_EACH_ENTRY( irp, &file->requests, struct irp_call, dev_entry )
476 switch (irp->params.major)
478 case IRP_MJ_CLOSE: irp->params.close.file = ptr; break;
479 case IRP_MJ_READ: irp->params.read.file = ptr; break;
480 case IRP_MJ_WRITE: irp->params.write.file = ptr; break;
481 case IRP_MJ_FLUSH_BUFFERS: irp->params.flush.file = ptr; break;
482 case IRP_MJ_DEVICE_CONTROL: irp->params.ioctl.file = ptr; break;
487 /* queue an irp to the device */
488 static obj_handle_t queue_irp( struct device_file *file, struct irp_call *irp,
489 const async_data_t *async_data, int blocking )
491 obj_handle_t handle = 0;
493 if (blocking && !(handle = alloc_handle( current->process, irp, SYNCHRONIZE, 0 ))) return 0;
495 if (!(irp->async = fd_queue_async( file->fd, async_data, ASYNC_TYPE_WAIT )))
497 if (handle) close_handle( current->process, handle );
498 return 0;
500 irp->user_arg = async_data->arg;
501 add_irp_to_queue( file, irp, current );
502 set_error( STATUS_PENDING );
503 return handle;
506 static enum server_fd_type device_file_get_fd_type( struct fd *fd )
508 return FD_TYPE_DEVICE;
511 static obj_handle_t device_file_read( struct fd *fd, const async_data_t *async_data, int blocking,
512 file_pos_t pos )
514 struct device_file *file = get_fd_user( fd );
515 struct irp_call *irp;
516 obj_handle_t handle;
517 irp_params_t params;
519 params.read.major = IRP_MJ_READ;
520 params.read.key = 0;
521 params.read.pos = pos;
522 params.read.file = file->user_ptr;
524 irp = create_irp( file, &params, NULL, 0, get_reply_max_size() );
525 if (!irp) return 0;
527 handle = queue_irp( file, irp, async_data, blocking );
528 release_object( irp );
529 return handle;
532 static obj_handle_t device_file_write( struct fd *fd, const async_data_t *async_data, int blocking,
533 file_pos_t pos, data_size_t *written )
535 struct device_file *file = get_fd_user( fd );
536 struct irp_call *irp;
537 obj_handle_t handle;
538 irp_params_t params;
540 params.write.major = IRP_MJ_WRITE;
541 params.write.key = 0;
542 params.write.pos = pos;
543 params.write.file = file->user_ptr;
545 irp = create_irp( file, &params, get_req_data(), get_req_data_size(), 0 );
546 if (!irp) return 0;
548 handle = queue_irp( file, irp, async_data, blocking );
549 release_object( irp );
550 return handle;
553 static obj_handle_t device_file_flush( struct fd *fd, const async_data_t *async_data, int blocking )
555 struct device_file *file = get_fd_user( fd );
556 struct irp_call *irp;
557 obj_handle_t handle;
558 irp_params_t params;
560 params.flush.major = IRP_MJ_FLUSH_BUFFERS;
561 params.flush.file = file->user_ptr;
563 irp = create_irp( file, &params, NULL, 0, 0 );
564 if (!irp) return 0;
566 handle = queue_irp( file, irp, async_data, blocking );
567 release_object( irp );
568 return handle;
571 static obj_handle_t device_file_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data,
572 int blocking )
574 struct device_file *file = get_fd_user( fd );
575 struct irp_call *irp;
576 obj_handle_t handle;
577 irp_params_t params;
579 params.ioctl.major = IRP_MJ_DEVICE_CONTROL;
580 params.ioctl.code = code;
581 params.ioctl.file = file->user_ptr;
583 irp = create_irp( file, &params, get_req_data(), get_req_data_size(),
584 get_reply_max_size() );
585 if (!irp) return 0;
587 handle = queue_irp( file, irp, async_data, blocking );
588 release_object( irp );
589 return handle;
592 static struct device *create_device( struct directory *root, const struct unicode_str *name,
593 struct device_manager *manager, unsigned int attr )
595 struct device *device;
597 if ((device = create_named_object_dir( root, name, attr, &device_ops )))
599 if (get_error() != STATUS_OBJECT_NAME_EXISTS)
601 /* initialize it if it didn't already exist */
602 device->unix_path = NULL;
603 device->manager = manager;
604 list_add_tail( &manager->devices, &device->entry );
605 list_init( &device->files );
608 return device;
611 struct device *create_unix_device( struct directory *root, const struct unicode_str *name,
612 const char *unix_path )
614 struct device *device;
616 if ((device = create_named_object_dir( root, name, 0, &device_ops )))
618 device->unix_path = strdup( unix_path );
619 device->manager = NULL; /* no manager, requests go straight to the Unix device */
620 list_init( &device->files );
621 make_object_static( &device->obj );
623 return device;
627 /* terminate requests when the underlying device is deleted */
628 static void delete_file( struct device_file *file )
630 struct irp_call *irp, *next;
632 /* terminate all pending requests */
633 LIST_FOR_EACH_ENTRY_SAFE( irp, next, &file->requests, struct irp_call, dev_entry )
635 list_remove( &irp->mgr_entry );
636 set_irp_result( irp, STATUS_FILE_DELETED, NULL, 0, 0 );
640 static void delete_device( struct device *device )
642 struct device_file *file, *next;
644 if (!device->manager) return; /* already deleted */
646 LIST_FOR_EACH_ENTRY_SAFE( file, next, &device->files, struct device_file, entry )
647 delete_file( file );
649 unlink_named_object( &device->obj );
650 list_remove( &device->entry );
651 device->manager = NULL;
655 static void device_manager_dump( struct object *obj, int verbose )
657 fprintf( stderr, "Device manager\n" );
660 static int device_manager_signaled( struct object *obj, struct wait_queue_entry *entry )
662 struct device_manager *manager = (struct device_manager *)obj;
664 return !list_empty( &manager->requests );
667 static void device_manager_destroy( struct object *obj )
669 struct device_manager *manager = (struct device_manager *)obj;
670 struct list *ptr;
672 while ((ptr = list_head( &manager->devices )))
674 struct device *device = LIST_ENTRY( ptr, struct device, entry );
675 delete_device( device );
679 static struct device_manager *create_device_manager(void)
681 struct device_manager *manager;
683 if ((manager = alloc_object( &device_manager_ops )))
685 list_init( &manager->devices );
686 list_init( &manager->requests );
688 return manager;
692 /* create a device manager */
693 DECL_HANDLER(create_device_manager)
695 struct device_manager *manager = create_device_manager();
697 if (manager)
699 reply->handle = alloc_handle( current->process, manager, req->access, req->attributes );
700 release_object( manager );
705 /* create a device */
706 DECL_HANDLER(create_device)
708 struct device *device;
709 struct unicode_str name;
710 struct device_manager *manager;
711 struct directory *root = NULL;
713 if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
714 0, &device_manager_ops )))
715 return;
717 get_req_unicode_str( &name );
718 if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
720 release_object( manager );
721 return;
724 if ((device = create_device( root, &name, manager, req->attributes )))
726 device->user_ptr = req->user_ptr;
727 reply->handle = alloc_handle( current->process, device, req->access, req->attributes );
728 release_object( device );
731 if (root) release_object( root );
732 release_object( manager );
736 /* delete a device */
737 DECL_HANDLER(delete_device)
739 struct device *device;
741 if ((device = (struct device *)get_handle_obj( current->process, req->handle, 0, &device_ops )))
743 delete_device( device );
744 release_object( device );
749 /* retrieve the next pending device irp request */
750 DECL_HANDLER(get_next_device_request)
752 struct irp_call *irp;
753 struct device_manager *manager;
754 struct list *ptr;
756 reply->params.major = IRP_MJ_MAXIMUM_FUNCTION + 1;
758 if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
759 0, &device_manager_ops )))
760 return;
762 if (req->prev)
764 if ((irp = (struct irp_call *)get_handle_obj( current->process, req->prev, 0, &irp_call_ops )))
766 set_irp_result( irp, req->status, NULL, 0, 0 );
767 close_handle( current->process, req->prev ); /* avoid an extra round-trip for close */
768 release_object( irp );
770 clear_error();
773 if ((ptr = list_head( &manager->requests )))
775 irp = LIST_ENTRY( ptr, struct irp_call, mgr_entry );
776 if (irp->thread)
778 reply->client_pid = get_process_id( irp->thread->process );
779 reply->client_tid = get_thread_id( irp->thread );
781 reply->params = irp->params;
782 reply->in_size = irp->in_size;
783 reply->out_size = irp->out_size;
784 if (irp->in_size > get_reply_max_size()) set_error( STATUS_BUFFER_OVERFLOW );
785 else if ((reply->next = alloc_handle( current->process, irp, 0, 0 )))
787 set_reply_data_ptr( irp->in_data, irp->in_size );
788 irp->in_data = NULL;
789 irp->in_size = 0;
790 list_remove( &irp->mgr_entry );
791 list_init( &irp->mgr_entry );
794 else set_error( STATUS_PENDING );
796 release_object( manager );
800 /* store results of an async irp */
801 DECL_HANDLER(set_irp_result)
803 struct irp_call *irp;
804 struct device_manager *manager;
806 if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
807 0, &device_manager_ops )))
808 return;
810 if ((irp = (struct irp_call *)get_handle_obj( current->process, req->handle, 0, &irp_call_ops )))
812 if (irp->file) set_file_user_ptr( irp->file, req->file_ptr );
813 set_irp_result( irp, req->status, get_req_data(), get_req_data_size(), req->size );
814 close_handle( current->process, req->handle ); /* avoid an extra round-trip for close */
815 release_object( irp );
817 release_object( manager );
821 /* retrieve results of an async irp */
822 DECL_HANDLER(get_irp_result)
824 struct device_file *file;
825 struct irp_call *irp;
827 if (!(file = (struct device_file *)get_handle_obj( current->process, req->handle,
828 0, &device_file_ops )))
829 return;
831 if ((irp = find_irp_call( file, current, req->user_arg )))
833 if (irp->out_data)
835 data_size_t size = min( irp->out_size, get_reply_max_size() );
836 if (size)
838 set_reply_data_ptr( irp->out_data, size );
839 irp->out_data = NULL;
842 reply->size = irp->result;
843 set_error( irp->status );
844 list_remove( &irp->dev_entry );
845 release_object( irp ); /* no longer on the device queue */
847 release_object( file );