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
22 #include "wine/port.h"
23 #include "wine/rbtree.h"
32 #define WIN32_NO_STATUS
47 struct object obj
; /* object header */
48 struct list dev_entry
; /* entry in device queue */
49 struct list mgr_entry
; /* entry in manager queue */
50 struct device_file
*file
; /* file containing this irp */
51 struct thread
*thread
; /* thread that queued the irp */
52 struct async
*async
; /* pending async op */
53 irp_params_t params
; /* irp parameters */
54 struct iosb
*iosb
; /* I/O status block */
55 int canceled
; /* the call was canceled */
56 client_ptr_t user_ptr
; /* client side pointer */
59 static void irp_call_dump( struct object
*obj
, int verbose
);
60 static void irp_call_destroy( struct object
*obj
);
62 static const struct object_ops irp_call_ops
=
64 sizeof(struct irp_call
), /* size */
66 irp_call_dump
, /* dump */
67 no_add_queue
, /* add_queue */
68 NULL
, /* remove_queue */
71 no_signal
, /* signal */
72 no_get_fd
, /* get_fd */
73 default_map_access
, /* map_access */
74 default_get_sd
, /* get_sd */
75 default_set_sd
, /* set_sd */
76 no_get_full_name
, /* get_full_name */
77 no_lookup_name
, /* lookup_name */
78 no_link_name
, /* link_name */
79 NULL
, /* unlink_name */
80 no_open_file
, /* open_file */
81 no_kernel_obj_list
, /* get_kernel_obj_list */
82 no_close_handle
, /* close_handle */
83 irp_call_destroy
/* destroy */
87 /* device manager (a list of devices managed by the same client process) */
91 struct object obj
; /* object header */
92 struct list devices
; /* list of devices */
93 struct list requests
; /* list of pending irps across all devices */
94 struct irp_call
*current_call
; /* call currently executed on client side */
95 struct wine_rb_tree kernel_objects
; /* map of objects that have client side pointer associated */
98 static void device_manager_dump( struct object
*obj
, int verbose
);
99 static int device_manager_signaled( struct object
*obj
, struct wait_queue_entry
*entry
);
100 static void device_manager_destroy( struct object
*obj
);
102 static const struct object_ops device_manager_ops
=
104 sizeof(struct device_manager
), /* size */
106 device_manager_dump
, /* dump */
107 add_queue
, /* add_queue */
108 remove_queue
, /* remove_queue */
109 device_manager_signaled
, /* signaled */
110 no_satisfied
, /* satisfied */
111 no_signal
, /* signal */
112 no_get_fd
, /* get_fd */
113 default_map_access
, /* map_access */
114 default_get_sd
, /* get_sd */
115 default_set_sd
, /* set_sd */
116 no_get_full_name
, /* get_full_name */
117 no_lookup_name
, /* lookup_name */
118 no_link_name
, /* link_name */
119 NULL
, /* unlink_name */
120 no_open_file
, /* open_file */
121 no_kernel_obj_list
, /* get_kernel_obj_list */
122 no_close_handle
, /* close_handle */
123 device_manager_destroy
/* destroy */
127 /* device (a single device object) */
129 static const WCHAR device_name
[] = {'D','e','v','i','c','e'};
131 struct type_descr device_type
=
133 { device_name
, sizeof(device_name
) }, /* name */
134 FILE_ALL_ACCESS
, /* valid_access */
138 FILE_GENERIC_EXECUTE
,
145 struct object obj
; /* object header */
146 struct device_manager
*manager
; /* manager for this device (or NULL if deleted) */
147 char *unix_path
; /* path to unix device if any */
148 struct list kernel_object
; /* list of kernel object pointers */
149 struct list entry
; /* entry in device manager list */
150 struct list files
; /* list of open files */
153 static void device_dump( struct object
*obj
, int verbose
);
154 static void device_destroy( struct object
*obj
);
155 static struct object
*device_open_file( struct object
*obj
, unsigned int access
,
156 unsigned int sharing
, unsigned int options
);
157 static struct list
*device_get_kernel_obj_list( struct object
*obj
);
159 static const struct object_ops device_ops
=
161 sizeof(struct device
), /* size */
162 &device_type
, /* type */
163 device_dump
, /* dump */
164 no_add_queue
, /* add_queue */
165 NULL
, /* remove_queue */
167 no_satisfied
, /* satisfied */
168 no_signal
, /* signal */
169 no_get_fd
, /* get_fd */
170 default_map_access
, /* map_access */
171 default_get_sd
, /* get_sd */
172 default_set_sd
, /* set_sd */
173 default_get_full_name
, /* get_full_name */
174 no_lookup_name
, /* lookup_name */
175 directory_link_name
, /* link_name */
176 default_unlink_name
, /* unlink_name */
177 device_open_file
, /* open_file */
178 device_get_kernel_obj_list
, /* get_kernel_obj_list */
179 no_close_handle
, /* close_handle */
180 device_destroy
/* destroy */
184 /* device file (an open file handle to a device) */
188 struct object obj
; /* object header */
189 struct device
*device
; /* device for this file */
190 struct fd
*fd
; /* file descriptor for irp */
191 struct list kernel_object
; /* list of kernel object pointers */
192 int closed
; /* closed file flag */
193 struct list entry
; /* entry in device list */
194 struct list requests
; /* list of pending irp requests */
197 static void device_file_dump( struct object
*obj
, int verbose
);
198 static struct fd
*device_file_get_fd( struct object
*obj
);
199 static WCHAR
*device_file_get_full_name( struct object
*obj
, data_size_t
*len
);
200 static struct list
*device_file_get_kernel_obj_list( struct object
*obj
);
201 static int device_file_close_handle( struct object
*obj
, struct process
*process
, obj_handle_t handle
);
202 static void device_file_destroy( struct object
*obj
);
203 static enum server_fd_type
device_file_get_fd_type( struct fd
*fd
);
204 static void device_file_read( struct fd
*fd
, struct async
*async
, file_pos_t pos
);
205 static void device_file_write( struct fd
*fd
, struct async
*async
, file_pos_t pos
);
206 static void device_file_flush( struct fd
*fd
, struct async
*async
);
207 static void device_file_ioctl( struct fd
*fd
, ioctl_code_t code
, struct async
*async
);
208 static void device_file_cancel_async( struct fd
*fd
, struct async
*async
);
209 static void device_file_get_volume_info( struct fd
*fd
, struct async
*async
, unsigned int info_class
);
211 static const struct object_ops device_file_ops
=
213 sizeof(struct device_file
), /* size */
214 &file_type
, /* type */
215 device_file_dump
, /* dump */
216 add_queue
, /* add_queue */
217 remove_queue
, /* remove_queue */
218 default_fd_signaled
, /* signaled */
219 no_satisfied
, /* satisfied */
220 no_signal
, /* signal */
221 device_file_get_fd
, /* get_fd */
222 default_map_access
, /* map_access */
223 default_get_sd
, /* get_sd */
224 default_set_sd
, /* set_sd */
225 device_file_get_full_name
, /* get_full_name */
226 no_lookup_name
, /* lookup_name */
227 no_link_name
, /* link_name */
228 NULL
, /* unlink_name */
229 no_open_file
, /* open_file */
230 device_file_get_kernel_obj_list
, /* get_kernel_obj_list */
231 device_file_close_handle
, /* close_handle */
232 device_file_destroy
/* destroy */
235 static const struct fd_ops device_file_fd_ops
=
237 default_fd_get_poll_events
, /* get_poll_events */
238 default_poll_event
, /* poll_event */
239 device_file_get_fd_type
, /* get_fd_type */
240 device_file_read
, /* read */
241 device_file_write
, /* write */
242 device_file_flush
, /* flush */
243 default_fd_get_file_info
, /* get_file_info */
244 device_file_get_volume_info
, /* get_volume_info */
245 device_file_ioctl
, /* ioctl */
246 device_file_cancel_async
, /* cancel_async */
247 default_fd_queue_async
, /* queue_async */
248 default_fd_reselect_async
, /* reselect_async */
252 struct list
*no_kernel_obj_list( struct object
*obj
)
259 struct device_manager
*manager
;
260 client_ptr_t user_ptr
;
261 struct object
*object
;
263 struct list list_entry
;
264 struct wine_rb_entry rb_entry
;
267 static int compare_kernel_object( const void *k
, const struct wine_rb_entry
*entry
)
269 struct kernel_object
*ptr
= WINE_RB_ENTRY_VALUE( entry
, struct kernel_object
, rb_entry
);
270 return memcmp( k
, &ptr
->user_ptr
, sizeof(client_ptr_t
) );
273 static struct kernel_object
*kernel_object_from_obj( struct device_manager
*manager
, struct object
*obj
)
275 struct kernel_object
*kernel_object
;
278 if (!(list
= obj
->ops
->get_kernel_obj_list( obj
))) return NULL
;
279 LIST_FOR_EACH_ENTRY( kernel_object
, list
, struct kernel_object
, list_entry
)
281 if (kernel_object
->manager
!= manager
) continue;
282 return kernel_object
;
287 static client_ptr_t
get_kernel_object_ptr( struct device_manager
*manager
, struct object
*obj
)
289 struct kernel_object
*kernel_object
= kernel_object_from_obj( manager
, obj
);
290 return kernel_object
? kernel_object
->user_ptr
: 0;
293 static struct kernel_object
*set_kernel_object( struct device_manager
*manager
, struct object
*obj
, client_ptr_t user_ptr
)
295 struct kernel_object
*kernel_object
;
298 if (!(list
= obj
->ops
->get_kernel_obj_list( obj
))) return NULL
;
300 if (!(kernel_object
= malloc( sizeof(*kernel_object
) ))) return NULL
;
301 kernel_object
->manager
= manager
;
302 kernel_object
->user_ptr
= user_ptr
;
303 kernel_object
->object
= obj
;
304 kernel_object
->owned
= 0;
306 if (wine_rb_put( &manager
->kernel_objects
, &user_ptr
, &kernel_object
->rb_entry
))
308 /* kernel_object pointer already set */
309 free( kernel_object
);
313 list_add_head( list
, &kernel_object
->list_entry
);
314 return kernel_object
;
317 static struct kernel_object
*kernel_object_from_ptr( struct device_manager
*manager
, client_ptr_t client_ptr
)
319 struct wine_rb_entry
*entry
= wine_rb_get( &manager
->kernel_objects
, &client_ptr
);
320 return entry
? WINE_RB_ENTRY_VALUE( entry
, struct kernel_object
, rb_entry
) : NULL
;
323 static void grab_kernel_object( struct kernel_object
*ptr
)
327 grab_object( ptr
->object
);
332 static void irp_call_dump( struct object
*obj
, int verbose
)
334 struct irp_call
*irp
= (struct irp_call
*)obj
;
335 fprintf( stderr
, "IRP call file=%p\n", irp
->file
);
338 static void irp_call_destroy( struct object
*obj
)
340 struct irp_call
*irp
= (struct irp_call
*)obj
;
344 async_terminate( irp
->async
, STATUS_CANCELLED
);
345 release_object( irp
->async
);
347 if (irp
->iosb
) release_object( irp
->iosb
);
348 if (irp
->file
) release_object( irp
->file
);
349 if (irp
->thread
) release_object( irp
->thread
);
352 static struct irp_call
*create_irp( struct device_file
*file
, const irp_params_t
*params
, struct async
*async
)
354 struct irp_call
*irp
;
356 if (file
&& !file
->device
->manager
) /* it has been deleted */
358 set_error( STATUS_FILE_DELETED
);
362 if ((irp
= alloc_object( &irp_call_ops
)))
364 irp
->file
= file
? (struct device_file
*)grab_object( file
) : NULL
;
367 irp
->params
= *params
;
372 if (async
) irp
->iosb
= async_get_iosb( async
);
377 static void set_irp_result( struct irp_call
*irp
, unsigned int status
,
378 const void *out_data
, data_size_t out_size
, data_size_t result
)
380 struct device_file
*file
= irp
->file
;
382 if (!file
) return; /* already finished */
384 /* remove it from the device queue */
385 list_remove( &irp
->dev_entry
);
389 out_size
= min( irp
->iosb
->out_size
, out_size
);
390 async_request_complete_alloc( irp
->async
, status
, result
, out_size
, out_data
);
391 release_object( irp
->async
);
395 release_object( irp
); /* no longer on the device queue */
396 release_object( file
);
400 static void device_dump( struct object
*obj
, int verbose
)
402 fputs( "Device\n", stderr
);
405 static void device_destroy( struct object
*obj
)
407 struct device
*device
= (struct device
*)obj
;
409 assert( list_empty( &device
->files
));
411 free( device
->unix_path
);
412 if (device
->manager
) list_remove( &device
->entry
);
415 static void add_irp_to_queue( struct device_manager
*manager
, struct irp_call
*irp
, struct thread
*thread
)
417 grab_object( irp
); /* grab reference for queued irp */
418 irp
->thread
= thread
? (struct thread
*)grab_object( thread
) : NULL
;
419 if (irp
->file
) list_add_tail( &irp
->file
->requests
, &irp
->dev_entry
);
420 list_add_tail( &manager
->requests
, &irp
->mgr_entry
);
421 if (list_head( &manager
->requests
) == &irp
->mgr_entry
) wake_up( &manager
->obj
, 0 ); /* first one */
424 static struct object
*device_open_file( struct object
*obj
, unsigned int access
,
425 unsigned int sharing
, unsigned int options
)
427 struct device
*device
= (struct device
*)obj
;
428 struct device_file
*file
;
429 struct unicode_str nt_name
;
431 if (!(file
= alloc_object( &device_file_ops
))) return NULL
;
433 file
->device
= (struct device
*)grab_object( device
);
435 list_init( &file
->kernel_object
);
436 list_init( &file
->requests
);
437 list_add_tail( &device
->files
, &file
->entry
);
438 if (device
->unix_path
)
441 access
= file
->obj
.ops
->map_access( &file
->obj
, access
);
442 nt_name
.str
= device
->obj
.ops
->get_full_name( &device
->obj
, &nt_name
.len
);
443 file
->fd
= open_fd( NULL
, device
->unix_path
, nt_name
, O_NONBLOCK
| O_LARGEFILE
,
444 &mode
, access
, sharing
, options
);
445 if (file
->fd
) set_fd_user( file
->fd
, &device_file_fd_ops
, &file
->obj
);
447 else file
->fd
= alloc_pseudo_fd( &device_file_fd_ops
, &file
->obj
, options
);
451 release_object( file
);
455 allow_fd_caching( file
->fd
);
459 struct irp_call
*irp
;
462 memset( ¶ms
, 0, sizeof(params
) );
463 params
.create
.type
= IRP_CALL_CREATE
;
464 params
.create
.access
= access
;
465 params
.create
.sharing
= sharing
;
466 params
.create
.options
= options
;
467 params
.create
.device
= get_kernel_object_ptr( device
->manager
, &device
->obj
);
469 if ((irp
= create_irp( file
, ¶ms
, NULL
)))
471 add_irp_to_queue( device
->manager
, irp
, current
);
472 release_object( irp
);
478 static struct list
*device_get_kernel_obj_list( struct object
*obj
)
480 struct device
*device
= (struct device
*)obj
;
481 return &device
->kernel_object
;
484 static void device_file_dump( struct object
*obj
, int verbose
)
486 struct device_file
*file
= (struct device_file
*)obj
;
488 fprintf( stderr
, "File on device %p\n", file
->device
);
491 static struct fd
*device_file_get_fd( struct object
*obj
)
493 struct device_file
*file
= (struct device_file
*)obj
;
495 return (struct fd
*)grab_object( file
->fd
);
498 static WCHAR
*device_file_get_full_name( struct object
*obj
, data_size_t
*len
)
500 struct device_file
*file
= (struct device_file
*)obj
;
501 return file
->device
->obj
.ops
->get_full_name( &file
->device
->obj
, len
);
504 static struct list
*device_file_get_kernel_obj_list( struct object
*obj
)
506 struct device_file
*file
= (struct device_file
*)obj
;
507 return &file
->kernel_object
;
510 static int device_file_close_handle( struct object
*obj
, struct process
*process
, obj_handle_t handle
)
512 struct device_file
*file
= (struct device_file
*)obj
;
514 if (!file
->closed
&& file
->device
->manager
&& obj
->handle_count
== 1) /* last handle */
516 struct irp_call
*irp
;
520 memset( ¶ms
, 0, sizeof(params
) );
521 params
.close
.type
= IRP_CALL_CLOSE
;
523 if ((irp
= create_irp( file
, ¶ms
, NULL
)))
525 add_irp_to_queue( file
->device
->manager
, irp
, current
);
526 release_object( irp
);
532 static void device_file_destroy( struct object
*obj
)
534 struct device_file
*file
= (struct device_file
*)obj
;
535 struct irp_call
*irp
, *next
;
537 LIST_FOR_EACH_ENTRY_SAFE( irp
, next
, &file
->requests
, struct irp_call
, dev_entry
)
539 list_remove( &irp
->dev_entry
);
540 release_object( irp
); /* no longer on the device queue */
542 if (file
->fd
) release_object( file
->fd
);
543 list_remove( &file
->entry
);
544 release_object( file
->device
);
547 static int fill_irp_params( struct device_manager
*manager
, struct irp_call
*irp
, irp_params_t
*params
)
549 switch (irp
->params
.type
)
553 case IRP_CALL_CANCEL
:
555 case IRP_CALL_CREATE
:
556 irp
->params
.create
.file
= alloc_handle( current
->process
, irp
->file
,
557 irp
->params
.create
.access
, 0 );
558 if (!irp
->params
.create
.file
) return 0;
561 irp
->params
.close
.file
= get_kernel_object_ptr( manager
, &irp
->file
->obj
);
564 irp
->params
.read
.file
= get_kernel_object_ptr( manager
, &irp
->file
->obj
);
565 irp
->params
.read
.out_size
= irp
->iosb
->out_size
;
568 irp
->params
.write
.file
= get_kernel_object_ptr( manager
, &irp
->file
->obj
);
571 irp
->params
.flush
.file
= get_kernel_object_ptr( manager
, &irp
->file
->obj
);
574 irp
->params
.ioctl
.file
= get_kernel_object_ptr( manager
, &irp
->file
->obj
);
575 irp
->params
.ioctl
.out_size
= irp
->iosb
->out_size
;
577 case IRP_CALL_VOLUME
:
578 irp
->params
.volume
.file
= get_kernel_object_ptr( manager
, &irp
->file
->obj
);
579 irp
->params
.volume
.out_size
= irp
->iosb
->out_size
;
583 *params
= irp
->params
;
587 static void free_irp_params( struct irp_call
*irp
)
589 switch (irp
->params
.type
)
591 case IRP_CALL_CREATE
:
592 close_handle( current
->process
, irp
->params
.create
.file
);
599 /* queue an irp to the device */
600 static void queue_irp( struct device_file
*file
, const irp_params_t
*params
, struct async
*async
)
602 struct irp_call
*irp
= create_irp( file
, params
, async
);
605 fd_queue_async( file
->fd
, async
, ASYNC_TYPE_WAIT
);
606 irp
->async
= (struct async
*)grab_object( async
);
607 add_irp_to_queue( file
->device
->manager
, irp
, current
);
608 release_object( irp
);
609 async_set_unknown_status( async
);
612 static enum server_fd_type
device_file_get_fd_type( struct fd
*fd
)
614 return FD_TYPE_DEVICE
;
617 static void device_file_get_volume_info( struct fd
*fd
, struct async
*async
, unsigned int info_class
)
619 struct device_file
*file
= get_fd_user( fd
);
622 memset( ¶ms
, 0, sizeof(params
) );
623 params
.volume
.type
= IRP_CALL_VOLUME
;
624 params
.volume
.info_class
= info_class
;
625 queue_irp( file
, ¶ms
, async
);
628 static void device_file_read( struct fd
*fd
, struct async
*async
, file_pos_t pos
)
630 struct device_file
*file
= get_fd_user( fd
);
633 memset( ¶ms
, 0, sizeof(params
) );
634 params
.read
.type
= IRP_CALL_READ
;
636 params
.read
.pos
= pos
;
637 queue_irp( file
, ¶ms
, async
);
640 static void device_file_write( struct fd
*fd
, struct async
*async
, file_pos_t pos
)
642 struct device_file
*file
= get_fd_user( fd
);
645 memset( ¶ms
, 0, sizeof(params
) );
646 params
.write
.type
= IRP_CALL_WRITE
;
647 params
.write
.key
= 0;
648 params
.write
.pos
= pos
;
649 queue_irp( file
, ¶ms
, async
);
652 static void device_file_flush( struct fd
*fd
, struct async
*async
)
654 struct device_file
*file
= get_fd_user( fd
);
657 memset( ¶ms
, 0, sizeof(params
) );
658 params
.flush
.type
= IRP_CALL_FLUSH
;
659 queue_irp( file
, ¶ms
, async
);
662 static void device_file_ioctl( struct fd
*fd
, ioctl_code_t code
, struct async
*async
)
664 struct device_file
*file
= get_fd_user( fd
);
667 memset( ¶ms
, 0, sizeof(params
) );
668 params
.ioctl
.type
= IRP_CALL_IOCTL
;
669 params
.ioctl
.code
= code
;
670 queue_irp( file
, ¶ms
, async
);
673 static void cancel_irp_call( struct irp_call
*irp
)
675 struct irp_call
*cancel_irp
;
679 if (!irp
->user_ptr
|| !irp
->file
|| !irp
->file
->device
->manager
) return;
681 memset( ¶ms
, 0, sizeof(params
) );
682 params
.cancel
.type
= IRP_CALL_CANCEL
;
683 params
.cancel
.irp
= irp
->user_ptr
;
685 if ((cancel_irp
= create_irp( NULL
, ¶ms
, NULL
)))
687 add_irp_to_queue( irp
->file
->device
->manager
, cancel_irp
, NULL
);
688 release_object( cancel_irp
);
692 static void device_file_cancel_async( struct fd
*fd
, struct async
*async
)
694 struct device_file
*file
= get_fd_user( fd
);
695 struct irp_call
*irp
;
697 LIST_FOR_EACH_ENTRY( irp
, &file
->requests
, struct irp_call
, dev_entry
)
699 if (irp
->async
== async
)
701 cancel_irp_call( irp
);
707 static struct device
*create_device( struct object
*root
, const struct unicode_str
*name
,
708 struct device_manager
*manager
)
710 struct device
*device
;
712 if ((device
= create_named_object( root
, &device_ops
, name
, 0, NULL
)))
714 device
->unix_path
= NULL
;
715 device
->manager
= manager
;
716 grab_object( device
);
717 list_add_tail( &manager
->devices
, &device
->entry
);
718 list_init( &device
->kernel_object
);
719 list_init( &device
->files
);
724 struct object
*create_unix_device( struct object
*root
, const struct unicode_str
*name
,
725 unsigned int attr
, const struct security_descriptor
*sd
,
726 const char *unix_path
)
728 struct device
*device
;
730 if ((device
= create_named_object( root
, &device_ops
, name
, attr
, sd
)))
732 device
->unix_path
= strdup( unix_path
);
733 device
->manager
= NULL
; /* no manager, requests go straight to the Unix device */
734 list_init( &device
->kernel_object
);
735 list_init( &device
->files
);
741 /* terminate requests when the underlying device is deleted */
742 static void delete_file( struct device_file
*file
)
744 struct irp_call
*irp
, *next
;
746 /* the pending requests may be the only thing holding a reference to the file */
749 /* terminate all pending requests */
750 LIST_FOR_EACH_ENTRY_SAFE( irp
, next
, &file
->requests
, struct irp_call
, dev_entry
)
752 list_remove( &irp
->mgr_entry
);
753 set_irp_result( irp
, STATUS_FILE_DELETED
, NULL
, 0, 0 );
756 release_object( file
);
759 static void delete_device( struct device
*device
)
761 struct device_file
*file
, *next
;
763 if (!device
->manager
) return; /* already deleted */
765 LIST_FOR_EACH_ENTRY_SAFE( file
, next
, &device
->files
, struct device_file
, entry
)
768 unlink_named_object( &device
->obj
);
769 list_remove( &device
->entry
);
770 device
->manager
= NULL
;
771 release_object( device
);
775 static void device_manager_dump( struct object
*obj
, int verbose
)
777 fprintf( stderr
, "Device manager\n" );
780 static int device_manager_signaled( struct object
*obj
, struct wait_queue_entry
*entry
)
782 struct device_manager
*manager
= (struct device_manager
*)obj
;
784 return !list_empty( &manager
->requests
);
787 static void device_manager_destroy( struct object
*obj
)
789 struct device_manager
*manager
= (struct device_manager
*)obj
;
790 struct kernel_object
*kernel_object
;
793 if (manager
->current_call
)
795 release_object( manager
->current_call
);
796 manager
->current_call
= NULL
;
799 while (manager
->kernel_objects
.root
)
801 kernel_object
= WINE_RB_ENTRY_VALUE( manager
->kernel_objects
.root
, struct kernel_object
, rb_entry
);
802 wine_rb_remove( &manager
->kernel_objects
, &kernel_object
->rb_entry
);
803 list_remove( &kernel_object
->list_entry
);
804 if (kernel_object
->owned
) release_object( kernel_object
->object
);
805 free( kernel_object
);
808 while ((ptr
= list_head( &manager
->devices
)))
810 struct device
*device
= LIST_ENTRY( ptr
, struct device
, entry
);
811 delete_device( device
);
814 while ((ptr
= list_head( &manager
->requests
)))
816 struct irp_call
*irp
= LIST_ENTRY( ptr
, struct irp_call
, mgr_entry
);
817 list_remove( &irp
->mgr_entry
);
818 assert( !irp
->file
&& !irp
->async
);
819 release_object( irp
);
823 static struct device_manager
*create_device_manager(void)
825 struct device_manager
*manager
;
827 if ((manager
= alloc_object( &device_manager_ops
)))
829 manager
->current_call
= NULL
;
830 list_init( &manager
->devices
);
831 list_init( &manager
->requests
);
832 wine_rb_init( &manager
->kernel_objects
, compare_kernel_object
);
837 void free_kernel_objects( struct object
*obj
)
839 struct list
*ptr
, *list
;
841 if (!(list
= obj
->ops
->get_kernel_obj_list( obj
))) return;
843 while ((ptr
= list_head( list
)))
845 struct kernel_object
*kernel_object
= LIST_ENTRY( ptr
, struct kernel_object
, list_entry
);
846 struct irp_call
*irp
;
849 assert( !kernel_object
->owned
);
851 memset( ¶ms
, 0, sizeof(params
) );
852 params
.free
.type
= IRP_CALL_FREE
;
853 params
.free
.obj
= kernel_object
->user_ptr
;
855 if ((irp
= create_irp( NULL
, ¶ms
, NULL
)))
857 add_irp_to_queue( kernel_object
->manager
, irp
, NULL
);
858 release_object( irp
);
861 list_remove( &kernel_object
->list_entry
);
862 wine_rb_remove( &kernel_object
->manager
->kernel_objects
, &kernel_object
->rb_entry
);
863 free( kernel_object
);
868 /* create a device manager */
869 DECL_HANDLER(create_device_manager
)
871 struct device_manager
*manager
= create_device_manager();
875 reply
->handle
= alloc_handle( current
->process
, manager
, req
->access
, req
->attributes
);
876 release_object( manager
);
881 /* create a device */
882 DECL_HANDLER(create_device
)
884 struct device
*device
;
885 struct unicode_str name
= get_req_unicode_str();
886 struct device_manager
*manager
;
887 struct object
*root
= NULL
;
889 if (!(manager
= (struct device_manager
*)get_handle_obj( current
->process
, req
->manager
,
890 0, &device_manager_ops
)))
893 if (req
->rootdir
&& !(root
= get_directory_obj( current
->process
, req
->rootdir
)))
895 release_object( manager
);
899 if ((device
= create_device( root
, &name
, manager
)))
901 struct kernel_object
*ptr
= set_kernel_object( manager
, &device
->obj
, req
->user_ptr
);
903 grab_kernel_object( ptr
);
905 set_error( STATUS_NO_MEMORY
);
906 release_object( device
);
909 if (root
) release_object( root
);
910 release_object( manager
);
914 /* delete a device */
915 DECL_HANDLER(delete_device
)
917 struct device_manager
*manager
;
918 struct kernel_object
*ref
;
919 struct device
*device
;
921 if (!(manager
= (struct device_manager
*)get_handle_obj( current
->process
, req
->manager
,
922 0, &device_manager_ops
)))
925 if ((ref
= kernel_object_from_ptr( manager
, req
->device
)) && ref
->object
->ops
== &device_ops
)
927 device
= (struct device
*)grab_object( ref
->object
);
928 delete_device( device
);
929 release_object( device
);
931 else set_error( STATUS_INVALID_HANDLE
);
933 release_object( manager
);
937 /* retrieve the next pending device irp request */
938 DECL_HANDLER(get_next_device_request
)
940 struct irp_call
*irp
;
941 struct device_manager
*manager
;
945 if (!(manager
= (struct device_manager
*)get_handle_obj( current
->process
, req
->manager
,
946 0, &device_manager_ops
)))
949 /* process result of previous call */
950 if (manager
->current_call
)
952 irp
= manager
->current_call
;
953 irp
->user_ptr
= req
->user_ptr
;
958 set_async_pending( irp
->async
);
959 async_set_initial_status( irp
->async
, req
->status
);
963 set_irp_result( irp
, req
->iosb_status
, get_req_data(), get_req_data_size(), req
->result
);
964 close_handle( current
->process
, req
->prev
); /* avoid an extra round-trip for close */
968 async_wake_obj( irp
->async
);
971 /* if it was canceled during dispatch, we couldn't queue cancel
972 * call without client pointer, so we need to do it now */
973 cancel_irp_call( irp
);
979 set_irp_result( irp
, req
->status
, NULL
, 0, 0 );
982 free_irp_params( irp
);
983 release_object( irp
);
984 manager
->current_call
= NULL
;
989 if ((ptr
= list_head( &manager
->requests
)))
991 struct thread
*thread
;
993 irp
= LIST_ENTRY( ptr
, struct irp_call
, mgr_entry
);
995 thread
= irp
->thread
? irp
->thread
: current
;
996 reply
->client_thread
= get_kernel_object_ptr( manager
, &thread
->obj
);
997 reply
->client_tid
= get_thread_id( thread
);
1001 reply
->in_size
= iosb
->in_size
;
1003 if (iosb
&& iosb
->in_size
> get_reply_max_size())
1004 set_error( STATUS_BUFFER_OVERFLOW
);
1005 else if (!irp
->file
|| (reply
->next
= alloc_handle( current
->process
, irp
, 0, 0 )))
1007 if (fill_irp_params( manager
, irp
, &reply
->params
))
1011 set_reply_data_ptr( iosb
->in_data
, iosb
->in_size
);
1012 iosb
->in_data
= NULL
;
1015 list_remove( &irp
->mgr_entry
);
1016 list_init( &irp
->mgr_entry
);
1017 /* we already own the object if it's only on manager queue */
1018 if (irp
->file
) grab_object( irp
);
1019 manager
->current_call
= irp
;
1021 else close_handle( current
->process
, reply
->next
);
1024 else set_error( STATUS_PENDING
);
1026 release_object( manager
);
1030 /* store results of an async irp */
1031 DECL_HANDLER(set_irp_result
)
1033 struct irp_call
*irp
;
1035 if ((irp
= (struct irp_call
*)get_handle_obj( current
->process
, req
->handle
, 0, &irp_call_ops
)))
1037 set_irp_result( irp
, req
->status
, get_req_data(), get_req_data_size(), req
->size
);
1038 close_handle( current
->process
, req
->handle
); /* avoid an extra round-trip for close */
1039 release_object( irp
);
1044 /* get kernel pointer from server object */
1045 DECL_HANDLER(get_kernel_object_ptr
)
1047 struct device_manager
*manager
;
1048 struct object
*object
= NULL
;
1050 if (!(manager
= (struct device_manager
*)get_handle_obj( current
->process
, req
->manager
,
1051 0, &device_manager_ops
)))
1054 if ((object
= get_handle_obj( current
->process
, req
->handle
, 0, NULL
)))
1056 reply
->user_ptr
= get_kernel_object_ptr( manager
, object
);
1057 release_object( object
);
1060 release_object( manager
);
1064 /* associate kernel pointer with server object */
1065 DECL_HANDLER(set_kernel_object_ptr
)
1067 struct device_manager
*manager
;
1068 struct object
*object
= NULL
;
1070 if (!(manager
= (struct device_manager
*)get_handle_obj( current
->process
, req
->manager
,
1071 0, &device_manager_ops
)))
1074 if (!(object
= get_handle_obj( current
->process
, req
->handle
, 0, NULL
)))
1076 release_object( manager
);
1080 if (!set_kernel_object( manager
, object
, req
->user_ptr
))
1081 set_error( STATUS_INVALID_HANDLE
);
1083 release_object( object
);
1084 release_object( manager
);
1088 /* grab server object reference from kernel object pointer */
1089 DECL_HANDLER(grab_kernel_object
)
1091 struct device_manager
*manager
;
1092 struct kernel_object
*ref
;
1094 if (!(manager
= (struct device_manager
*)get_handle_obj( current
->process
, req
->manager
,
1095 0, &device_manager_ops
)))
1098 if ((ref
= kernel_object_from_ptr( manager
, req
->user_ptr
)) && !ref
->owned
)
1099 grab_kernel_object( ref
);
1101 set_error( STATUS_INVALID_HANDLE
);
1103 release_object( manager
);
1107 /* release server object reference from kernel object pointer */
1108 DECL_HANDLER(release_kernel_object
)
1110 struct device_manager
*manager
;
1111 struct kernel_object
*ref
;
1113 if (!(manager
= (struct device_manager
*)get_handle_obj( current
->process
, req
->manager
,
1114 0, &device_manager_ops
)))
1117 if ((ref
= kernel_object_from_ptr( manager
, req
->user_ptr
)) && ref
->owned
)
1120 release_object( ref
->object
);
1122 else set_error( STATUS_INVALID_HANDLE
);
1124 release_object( manager
);
1128 /* get handle from kernel object pointer */
1129 DECL_HANDLER(get_kernel_object_handle
)
1131 struct device_manager
*manager
;
1132 struct kernel_object
*ref
;
1134 if (!(manager
= (struct device_manager
*)get_handle_obj( current
->process
, req
->manager
,
1135 0, &device_manager_ops
)))
1138 if ((ref
= kernel_object_from_ptr( manager
, req
->user_ptr
)))
1139 reply
->handle
= alloc_handle( current
->process
, ref
->object
, req
->access
, 0 );
1141 set_error( STATUS_INVALID_HANDLE
);
1143 release_object( manager
);