server/device.c

   1 /*
   2  * Server-side device support
   3  *
   4  * Copyright (C) 2007 Alexandre Julliard
   5  *
   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.
  10  *
  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.
  15  *
  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
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23 #include "wine/rbtree.h"
  24
  25 #include <assert.h>
  26 #include <fcntl.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <stdarg.h>
  30
  31 #include "ntstatus.h"
  32 #define WIN32_NO_STATUS
  33 #include "windef.h"
  34 #include "winternl.h"
  35 #include "ddk/wdm.h"
  36
  37 #include "object.h"
  38 #include "file.h"
  39 #include "handle.h"
  40 #include "request.h"
  41 #include "process.h"
  42
  43 /* IRP object */
  44
  45 struct irp_call
  46 {
  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 };
  56
  57 static void irp_call_dump( struct object *obj, int verbose );
  58 static int irp_call_signaled( struct object *obj, struct wait_queue_entry *entry );
  59 static void irp_call_destroy( struct object *obj );
  60
  61 static const struct object_ops irp_call_ops =
  62 {
  63     sizeof(struct irp_call),          /* size */
  64     irp_call_dump,                    /* dump */
  65     no_get_type,                      /* get_type */
  66     add_queue,                        /* add_queue */
  67     remove_queue,                     /* remove_queue */
  68     irp_call_signaled,                /* signaled */
  69     no_satisfied,                     /* satisfied */
  70     no_signal,                        /* signal */
  71     no_get_fd,                        /* get_fd */
  72     no_map_access,                    /* map_access */
  73     default_get_sd,                   /* get_sd */
  74     default_set_sd,                   /* set_sd */
  75     no_lookup_name,                   /* lookup_name */
  76     no_link_name,                     /* link_name */
  77     NULL,                             /* unlink_name */
  78     no_open_file,                     /* open_file */
  79     no_kernel_obj_list,               /* get_kernel_obj_list */
  80     no_close_handle,                  /* close_handle */
  81     irp_call_destroy                  /* destroy */
  82 };
  83
  84
  85 /* device manager (a list of devices managed by the same client process) */
  86
  87 struct device_manager
  88 {
  89     struct object          obj;            /* object header */
  90     struct list            devices;        /* list of devices */
  91     struct list            requests;       /* list of pending irps across all devices */
  92     struct wine_rb_tree    kernel_objects; /* map of objects that have client side pointer associated */
  93 };
  94
  95 static void device_manager_dump( struct object *obj, int verbose );
  96 static int device_manager_signaled( struct object *obj, struct wait_queue_entry *entry );
  97 static void device_manager_destroy( struct object *obj );
  98
  99 static const struct object_ops device_manager_ops =
 100 {
 101     sizeof(struct device_manager),    /* size */
 102     device_manager_dump,              /* dump */
 103     no_get_type,                      /* get_type */
 104     add_queue,                        /* add_queue */
 105     remove_queue,                     /* remove_queue */
 106     device_manager_signaled,          /* signaled */
 107     no_satisfied,                     /* satisfied */
 108     no_signal,                        /* signal */
 109     no_get_fd,                        /* get_fd */
 110     no_map_access,                    /* map_access */
 111     default_get_sd,                   /* get_sd */
 112     default_set_sd,                   /* set_sd */
 113     no_lookup_name,                   /* lookup_name */
 114     no_link_name,                     /* link_name */
 115     NULL,                             /* unlink_name */
 116     no_open_file,                     /* open_file */
 117     no_kernel_obj_list,               /* get_kernel_obj_list */
 118     no_close_handle,                  /* close_handle */
 119     device_manager_destroy            /* destroy */
 120 };
 121
 122
 123 /* device (a single device object) */
 124
 125 struct device
 126 {
 127     struct object          obj;           /* object header */
 128     struct device_manager *manager;       /* manager for this device (or NULL if deleted) */
 129     char                  *unix_path;     /* path to unix device if any */
 130     client_ptr_t           user_ptr;      /* opaque ptr for client side */
 131     struct list            entry;         /* entry in device manager list */
 132     struct list            files;         /* list of open files */
 133 };
 134
 135 static void device_dump( struct object *obj, int verbose );
 136 static struct object_type *device_get_type( struct object *obj );
 137 static void device_destroy( struct object *obj );
 138 static struct object *device_open_file( struct object *obj, unsigned int access,
 139                                         unsigned int sharing, unsigned int options );
 140
 141 static const struct object_ops device_ops =
 142 {
 143     sizeof(struct device),            /* size */
 144     device_dump,                      /* dump */
 145     device_get_type,                  /* get_type */
 146     no_add_queue,                     /* add_queue */
 147     NULL,                             /* remove_queue */
 148     NULL,                             /* signaled */
 149     no_satisfied,                     /* satisfied */
 150     no_signal,                        /* signal */
 151     no_get_fd,                        /* get_fd */
 152     default_fd_map_access,            /* map_access */
 153     default_get_sd,                   /* get_sd */
 154     default_set_sd,                   /* set_sd */
 155     no_lookup_name,                   /* lookup_name */
 156     directory_link_name,              /* link_name */
 157     default_unlink_name,              /* unlink_name */
 158     device_open_file,                 /* open_file */
 159     no_kernel_obj_list,               /* get_kernel_obj_list */
 160     no_close_handle,                  /* close_handle */
 161     device_destroy                    /* destroy */
 162 };
 163
 164
 165 /* device file (an open file handle to a device) */
 166
 167 struct device_file
 168 {
 169     struct object          obj;           /* object header */
 170     struct device         *device;        /* device for this file */
 171     struct fd             *fd;            /* file descriptor for irp */
 172     client_ptr_t           user_ptr;      /* opaque ptr for client side */
 173     struct list            entry;         /* entry in device list */
 174     struct list            requests;      /* list of pending irp requests */
 175 };
 176
 177 static void device_file_dump( struct object *obj, int verbose );
 178 static struct fd *device_file_get_fd( struct object *obj );
 179 static int device_file_close_handle( struct object *obj, struct process *process, obj_handle_t handle );
 180 static void device_file_destroy( struct object *obj );
 181 static enum server_fd_type device_file_get_fd_type( struct fd *fd );
 182 static int device_file_read( struct fd *fd, struct async *async, file_pos_t pos );
 183 static int device_file_write( struct fd *fd, struct async *async, file_pos_t pos );
 184 static int device_file_flush( struct fd *fd, struct async *async );
 185 static int device_file_ioctl( struct fd *fd, ioctl_code_t code, struct async *async );
 186
 187 static const struct object_ops device_file_ops =
 188 {
 189     sizeof(struct device_file),       /* size */
 190     device_file_dump,                 /* dump */
 191     file_get_type,                    /* get_type */
 192     add_queue,                        /* add_queue */
 193     remove_queue,                     /* remove_queue */
 194     default_fd_signaled,              /* signaled */
 195     no_satisfied,                     /* satisfied */
 196     no_signal,                        /* signal */
 197     device_file_get_fd,               /* get_fd */
 198     default_fd_map_access,            /* map_access */
 199     default_get_sd,                   /* get_sd */
 200     default_set_sd,                   /* set_sd */
 201     no_lookup_name,                   /* lookup_name */
 202     no_link_name,                     /* link_name */
 203     NULL,                             /* unlink_name */
 204     no_open_file,                     /* open_file */
 205     no_kernel_obj_list,               /* get_kernel_obj_list */
 206     device_file_close_handle,         /* close_handle */
 207     device_file_destroy               /* destroy */
 208 };
 209
 210 static const struct fd_ops device_file_fd_ops =
 211 {
 212     default_fd_get_poll_events,       /* get_poll_events */
 213     default_poll_event,               /* poll_event */
 214     device_file_get_fd_type,          /* get_fd_type */
 215     device_file_read,                 /* read */
 216     device_file_write,                /* write */
 217     device_file_flush,                /* flush */
 218     default_fd_get_file_info,         /* get_file_info */
 219     no_fd_get_volume_info,            /* get_volume_info */
 220     device_file_ioctl,                /* ioctl */
 221     default_fd_queue_async,           /* queue_async */
 222     default_fd_reselect_async         /* reselect_async */
 223 };
 224
 225
 226 struct list *no_kernel_obj_list( struct object *obj )
 227 {
 228     return NULL;
 229 }
 230
 231 struct kernel_object
 232 {
 233     struct device_manager  *manager;
 234     client_ptr_t            user_ptr;
 235     struct object          *object;
 236     int                     owned;
 237     struct list             list_entry;
 238     struct wine_rb_entry    rb_entry;
 239 };
 240
 241 static int compare_kernel_object( const void *k, const struct wine_rb_entry *entry )
 242 {
 243     struct kernel_object *ptr = WINE_RB_ENTRY_VALUE( entry, struct kernel_object, rb_entry );
 244     return memcmp( k, &ptr->user_ptr, sizeof(client_ptr_t) );
 245 }
 246
 247 static struct kernel_object *kernel_object_from_obj( struct device_manager *manager, struct object *obj )
 248 {
 249     struct kernel_object *kernel_object;
 250     struct list *list;
 251
 252     if (!(list = obj->ops->get_kernel_obj_list( obj ))) return NULL;
 253     LIST_FOR_EACH_ENTRY( kernel_object, list, struct kernel_object, list_entry )
 254     {
 255         if (kernel_object->manager != manager) continue;
 256         return kernel_object;
 257     }
 258     return NULL;
 259 }
 260
 261 static client_ptr_t get_kernel_object_ptr( struct device_manager *manager, struct object *obj )
 262 {
 263     struct kernel_object *kernel_object = kernel_object_from_obj( manager, obj );
 264     return kernel_object ? kernel_object->user_ptr : 0;
 265 }
 266
 267 static struct kernel_object *set_kernel_object( struct device_manager *manager, struct object *obj, client_ptr_t user_ptr )
 268 {
 269     struct kernel_object *kernel_object;
 270     struct list *list;
 271
 272     if (!(list = obj->ops->get_kernel_obj_list( obj ))) return NULL;
 273
 274     if (!(kernel_object = malloc( sizeof(*kernel_object) ))) return NULL;
 275     kernel_object->manager  = manager;
 276     kernel_object->user_ptr = user_ptr;
 277     kernel_object->object   = obj;
 278     kernel_object->owned    = 0;
 279
 280     if (wine_rb_put( &manager->kernel_objects, &user_ptr, &kernel_object->rb_entry ))
 281     {
 282         /* kernel_object pointer already set */
 283         free( kernel_object );
 284         return NULL;
 285     }
 286
 287     list_add_head( list, &kernel_object->list_entry );
 288     return kernel_object;
 289 }
 290
 291 static struct kernel_object *kernel_object_from_ptr( struct device_manager *manager, client_ptr_t client_ptr )
 292 {
 293     struct wine_rb_entry *entry = wine_rb_get( &manager->kernel_objects, &client_ptr );
 294     return entry ? WINE_RB_ENTRY_VALUE( entry, struct kernel_object, rb_entry ) : NULL;
 295 }
 296
 297 static void grab_kernel_object( struct kernel_object *ptr )
 298 {
 299     if (!ptr->owned)
 300     {
 301         grab_object( ptr->object );
 302         ptr->owned = 1;
 303     }
 304 }
 305
 306 static void irp_call_dump( struct object *obj, int verbose )
 307 {
 308     struct irp_call *irp = (struct irp_call *)obj;
 309     fprintf( stderr, "IRP call file=%p\n", irp->file );
 310 }
 311
 312 static int irp_call_signaled( struct object *obj, struct wait_queue_entry *entry )
 313 {
 314     struct irp_call *irp = (struct irp_call *)obj;
 315
 316     return !irp->file;  /* file is cleared once the irp has completed */
 317 }
 318
 319 static void irp_call_destroy( struct object *obj )
 320 {
 321     struct irp_call *irp = (struct irp_call *)obj;
 322
 323     if (irp->async)
 324     {
 325         async_terminate( irp->async, STATUS_CANCELLED );
 326         release_object( irp->async );
 327     }
 328     if (irp->iosb) release_object( irp->iosb );
 329     if (irp->file) release_object( irp->file );
 330     if (irp->thread) release_object( irp->thread );
 331 }
 332
 333 static struct irp_call *create_irp( struct device_file *file, const irp_params_t *params, struct async *async )
 334 {
 335     struct irp_call *irp;
 336
 337     if (file && !file->device->manager)  /* it has been deleted */
 338     {
 339         set_error( STATUS_FILE_DELETED );
 340         return NULL;
 341     }
 342
 343     if ((irp = alloc_object( &irp_call_ops )))
 344     {
 345         irp->file     = file ? (struct device_file *)grab_object( file ) : NULL;
 346         irp->thread   = NULL;
 347         irp->async    = NULL;
 348         irp->params   = *params;
 349         irp->iosb     = NULL;
 350
 351         if (async) irp->iosb = async_get_iosb( async );
 352         if (!irp->iosb && !(irp->iosb = create_iosb( NULL, 0, 0 )))
 353         {
 354             release_object( irp );
 355             irp = NULL;
 356         }
 357     }
 358     return irp;
 359 }
 360
 361 static void set_irp_result( struct irp_call *irp, unsigned int status,
 362                             const void *out_data, data_size_t out_size, data_size_t result )
 363 {
 364     struct device_file *file = irp->file;
 365     struct iosb *iosb = irp->iosb;
 366
 367     if (!file) return;  /* already finished */
 368
 369     /* FIXME: handle the STATUS_PENDING case */
 370     iosb->status = status;
 371     iosb->result = result;
 372     iosb->out_size = min( iosb->out_size, out_size );
 373     if (iosb->out_size && !(iosb->out_data = memdup( out_data, iosb->out_size )))
 374         iosb->out_size = 0;
 375     irp->file = NULL;
 376     if (irp->async)
 377     {
 378         if (result) status = STATUS_ALERTED;
 379         async_terminate( irp->async, status );
 380         release_object( irp->async );
 381         irp->async = NULL;
 382     }
 383     wake_up( &irp->obj, 0 );
 384
 385     /* remove it from the device queue */
 386     list_remove( &irp->dev_entry );
 387     release_object( irp );  /* no longer on the device queue */
 388     release_object( file );
 389 }
 390
 391
 392 static void device_dump( struct object *obj, int verbose )
 393 {
 394     fputs( "Device\n", stderr );
 395 }
 396
 397 static struct object_type *device_get_type( struct object *obj )
 398 {
 399     static const WCHAR name[] = {'D','e','v','i','c','e'};
 400     static const struct unicode_str str = { name, sizeof(name) };
 401     return get_object_type( &str );
 402 }
 403
 404 static void device_destroy( struct object *obj )
 405 {
 406     struct device *device = (struct device *)obj;
 407
 408     assert( list_empty( &device->files ));
 409
 410     free( device->unix_path );
 411     if (device->manager) list_remove( &device->entry );
 412 }
 413
 414 static void add_irp_to_queue( struct device_manager *manager, struct irp_call *irp, struct thread *thread )
 415 {
 416     grab_object( irp );  /* grab reference for queued irp */
 417     irp->thread = thread ? (struct thread *)grab_object( thread ) : NULL;
 418     if (irp->file) list_add_tail( &irp->file->requests, &irp->dev_entry );
 419     list_add_tail( &manager->requests, &irp->mgr_entry );
 420     if (list_head( &manager->requests ) == &irp->mgr_entry) wake_up( &manager->obj, 0 );  /* first one */
 421 }
 422
 423 static struct object *device_open_file( struct object *obj, unsigned int access,
 424                                         unsigned int sharing, unsigned int options )
 425 {
 426     struct device *device = (struct device *)obj;
 427     struct device_file *file;
 428
 429     if (!(file = alloc_object( &device_file_ops ))) return NULL;
 430
 431     file->device = (struct device *)grab_object( device );
 432     file->user_ptr = 0;
 433     list_init( &file->requests );
 434     list_add_tail( &device->files, &file->entry );
 435     if (device->unix_path)
 436     {
 437         mode_t mode = 0666;
 438         access = file->obj.ops->map_access( &file->obj, access );
 439         file->fd = open_fd( NULL, device->unix_path, O_NONBLOCK | O_LARGEFILE,
 440                             &mode, access, sharing, options );
 441         if (file->fd) set_fd_user( file->fd, &device_file_fd_ops, &file->obj );
 442     }
 443     else file->fd = alloc_pseudo_fd( &device_file_fd_ops, &file->obj, options );
 444
 445     if (!file->fd)
 446     {
 447         release_object( file );
 448         return NULL;
 449     }
 450
 451     allow_fd_caching( file->fd );
 452
 453     if (device->manager)
 454     {
 455         struct irp_call *irp;
 456         irp_params_t params;
 457
 458         memset( &params, 0, sizeof(params) );
 459         params.create.major   = IRP_MJ_CREATE;
 460         params.create.access  = access;
 461         params.create.sharing = sharing;
 462         params.create.options = options;
 463         params.create.device  = file->device->user_ptr;
 464
 465         if ((irp = create_irp( file, &params, NULL )))
 466         {
 467             add_irp_to_queue( device->manager, irp, NULL );
 468             release_object( irp );
 469         }
 470     }
 471     return &file->obj;
 472 }
 473
 474 static void device_file_dump( struct object *obj, int verbose )
 475 {
 476     struct device_file *file = (struct device_file *)obj;
 477
 478     fprintf( stderr, "File on device %p\n", file->device );
 479 }
 480
 481 static struct fd *device_file_get_fd( struct object *obj )
 482 {
 483     struct device_file *file = (struct device_file *)obj;
 484
 485     return (struct fd *)grab_object( file->fd );
 486 }
 487
 488 static int device_file_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
 489 {
 490     struct device_file *file = (struct device_file *)obj;
 491
 492     if (file->device->manager && obj->handle_count == 1)  /* last handle */
 493     {
 494         struct irp_call *irp;
 495         irp_params_t params;
 496
 497         memset( &params, 0, sizeof(params) );
 498         params.close.major = IRP_MJ_CLOSE;
 499         params.close.file  = file->user_ptr;
 500
 501         if ((irp = create_irp( file, &params, NULL )))
 502         {
 503             add_irp_to_queue( file->device->manager, irp, NULL );
 504             release_object( irp );
 505         }
 506     }
 507     return 1;
 508 }
 509
 510 static void device_file_destroy( struct object *obj )
 511 {
 512     struct device_file *file = (struct device_file *)obj;
 513     struct irp_call *irp, *next;
 514
 515     LIST_FOR_EACH_ENTRY_SAFE( irp, next, &file->requests, struct irp_call, dev_entry )
 516     {
 517         list_remove( &irp->dev_entry );
 518         release_object( irp );  /* no longer on the device queue */
 519     }
 520     if (file->fd) release_object( file->fd );
 521     list_remove( &file->entry );
 522     release_object( file->device );
 523 }
 524
 525 static void set_file_user_ptr( struct device_file *file, client_ptr_t ptr )
 526 {
 527     struct irp_call *irp;
 528
 529     if (file->user_ptr == ptr) return;  /* nothing to do */
 530
 531     file->user_ptr = ptr;
 532
 533     /* update already queued irps */
 534
 535     LIST_FOR_EACH_ENTRY( irp, &file->requests, struct irp_call, dev_entry )
 536     {
 537         switch (irp->params.major)
 538         {
 539         case IRP_MJ_CLOSE:          irp->params.close.file = ptr; break;
 540         case IRP_MJ_READ:           irp->params.read.file  = ptr; break;
 541         case IRP_MJ_WRITE:          irp->params.write.file = ptr; break;
 542         case IRP_MJ_FLUSH_BUFFERS:  irp->params.flush.file = ptr; break;
 543         case IRP_MJ_DEVICE_CONTROL: irp->params.ioctl.file = ptr; break;
 544         }
 545     }
 546 }
 547
 548 /* queue an irp to the device */
 549 static int queue_irp( struct device_file *file, const irp_params_t *params, struct async *async )
 550 {
 551     struct irp_call *irp = create_irp( file, params, async );
 552     if (!irp) return 0;
 553
 554     fd_queue_async( file->fd, async, ASYNC_TYPE_WAIT );
 555     irp->async = (struct async *)grab_object( async );
 556     add_irp_to_queue( file->device->manager, irp, current );
 557     release_object( irp );
 558     set_error( STATUS_PENDING );
 559     return 1;
 560 }
 561
 562 static enum server_fd_type device_file_get_fd_type( struct fd *fd )
 563 {
 564     return FD_TYPE_DEVICE;
 565 }
 566
 567 static int device_file_read( struct fd *fd, struct async *async, file_pos_t pos )
 568 {
 569     struct device_file *file = get_fd_user( fd );
 570     irp_params_t params;
 571
 572     memset( &params, 0, sizeof(params) );
 573     params.read.major = IRP_MJ_READ;
 574     params.read.key   = 0;
 575     params.read.pos   = pos;
 576     params.read.file  = file->user_ptr;
 577     return queue_irp( file, &params, async );
 578 }
 579
 580 static int device_file_write( struct fd *fd, struct async *async, file_pos_t pos )
 581 {
 582     struct device_file *file = get_fd_user( fd );
 583     irp_params_t params;
 584
 585     memset( &params, 0, sizeof(params) );
 586     params.write.major = IRP_MJ_WRITE;
 587     params.write.key   = 0;
 588     params.write.pos   = pos;
 589     params.write.file  = file->user_ptr;
 590     return queue_irp( file, &params, async );
 591 }
 592
 593 static int device_file_flush( struct fd *fd, struct async *async )
 594 {
 595     struct device_file *file = get_fd_user( fd );
 596     irp_params_t params;
 597
 598     memset( &params, 0, sizeof(params) );
 599     params.flush.major = IRP_MJ_FLUSH_BUFFERS;
 600     params.flush.file  = file->user_ptr;
 601     return queue_irp( file, &params, async );
 602 }
 603
 604 static int device_file_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
 605 {
 606     struct device_file *file = get_fd_user( fd );
 607     irp_params_t params;
 608
 609     memset( &params, 0, sizeof(params) );
 610     params.ioctl.major = IRP_MJ_DEVICE_CONTROL;
 611     params.ioctl.code  = code;
 612     params.ioctl.file = file->user_ptr;
 613     return queue_irp( file, &params, async );
 614 }
 615
 616 static struct device *create_device( struct object *root, const struct unicode_str *name,
 617                                      struct device_manager *manager, unsigned int attr )
 618 {
 619     struct device *device;
 620
 621     if ((device = create_named_object( root, &device_ops, name, attr, NULL )))
 622     {
 623         if (get_error() != STATUS_OBJECT_NAME_EXISTS)
 624         {
 625             /* initialize it if it didn't already exist */
 626             device->unix_path = NULL;
 627             device->manager = manager;
 628             list_add_tail( &manager->devices, &device->entry );
 629             list_init( &device->files );
 630         }
 631     }
 632     return device;
 633 }
 634
 635 struct object *create_unix_device( struct object *root, const struct unicode_str *name,
 636                                    const char *unix_path )
 637 {
 638     struct device *device;
 639
 640     if ((device = create_named_object( root, &device_ops, name, 0, NULL )))
 641     {
 642         device->unix_path = strdup( unix_path );
 643         device->manager = NULL;  /* no manager, requests go straight to the Unix device */
 644         list_init( &device->files );
 645     }
 646     return &device->obj;
 647
 648 }
 649
 650 /* terminate requests when the underlying device is deleted */
 651 static void delete_file( struct device_file *file )
 652 {
 653     struct irp_call *irp, *next;
 654
 655     /* terminate all pending requests */
 656     LIST_FOR_EACH_ENTRY_SAFE( irp, next, &file->requests, struct irp_call, dev_entry )
 657     {
 658         list_remove( &irp->mgr_entry );
 659         set_irp_result( irp, STATUS_FILE_DELETED, NULL, 0, 0 );
 660     }
 661 }
 662
 663 static void delete_device( struct device *device )
 664 {
 665     struct device_file *file, *next;
 666
 667     if (!device->manager) return;  /* already deleted */
 668
 669     LIST_FOR_EACH_ENTRY_SAFE( file, next, &device->files, struct device_file, entry )
 670         delete_file( file );
 671
 672     unlink_named_object( &device->obj );
 673     list_remove( &device->entry );
 674     device->manager = NULL;
 675 }
 676
 677
 678 static void device_manager_dump( struct object *obj, int verbose )
 679 {
 680     fprintf( stderr, "Device manager\n" );
 681 }
 682
 683 static int device_manager_signaled( struct object *obj, struct wait_queue_entry *entry )
 684 {
 685     struct device_manager *manager = (struct device_manager *)obj;
 686
 687     return !list_empty( &manager->requests );
 688 }
 689
 690 static void device_manager_destroy( struct object *obj )
 691 {
 692     struct device_manager *manager = (struct device_manager *)obj;
 693     struct kernel_object *kernel_object;
 694     struct list *ptr;
 695
 696     while (manager->kernel_objects.root)
 697     {
 698         kernel_object = WINE_RB_ENTRY_VALUE( manager->kernel_objects.root, struct kernel_object, rb_entry );
 699         wine_rb_remove( &manager->kernel_objects, &kernel_object->rb_entry );
 700         list_remove( &kernel_object->list_entry );
 701         if (kernel_object->owned) release_object( kernel_object->object );
 702         free( kernel_object );
 703     }
 704
 705     while ((ptr = list_head( &manager->devices )))
 706     {
 707         struct device *device = LIST_ENTRY( ptr, struct device, entry );
 708         delete_device( device );
 709     }
 710
 711     while ((ptr = list_head( &manager->requests )))
 712     {
 713         struct irp_call *irp = LIST_ENTRY( ptr, struct irp_call, mgr_entry );
 714         list_remove( &irp->mgr_entry );
 715         assert( !irp->file && !irp->async );
 716         release_object( irp );
 717     }
 718 }
 719
 720 static struct device_manager *create_device_manager(void)
 721 {
 722     struct device_manager *manager;
 723
 724     if ((manager = alloc_object( &device_manager_ops )))
 725     {
 726         list_init( &manager->devices );
 727         list_init( &manager->requests );
 728         wine_rb_init( &manager->kernel_objects, compare_kernel_object );
 729     }
 730     return manager;
 731 }
 732
 733 void free_kernel_objects( struct object *obj )
 734 {
 735     struct list *ptr, *list;
 736
 737     if (!(list = obj->ops->get_kernel_obj_list( obj ))) return;
 738
 739     while ((ptr = list_head( list )))
 740     {
 741         struct kernel_object *kernel_object = LIST_ENTRY( ptr, struct kernel_object, list_entry );
 742         struct irp_call *irp;
 743         irp_params_t params;
 744
 745         assert( !kernel_object->owned );
 746
 747         /* abuse IRP_MJ_CLEANUP to request client to free no longer valid kernel object */
 748         memset( &params, 0, sizeof(params) );
 749         params.cleanup.major = IRP_MJ_CLEANUP;
 750         params.cleanup.obj   = kernel_object->user_ptr;
 751
 752         if ((irp = create_irp( NULL, &params, NULL )))
 753         {
 754             add_irp_to_queue( kernel_object->manager, irp, NULL );
 755             release_object( irp );
 756         }
 757
 758         list_remove( &kernel_object->list_entry );
 759         wine_rb_remove( &kernel_object->manager->kernel_objects, &kernel_object->rb_entry );
 760         free( kernel_object );
 761     }
 762 }
 763
 764
 765 /* create a device manager */
 766 DECL_HANDLER(create_device_manager)
 767 {
 768     struct device_manager *manager = create_device_manager();
 769
 770     if (manager)
 771     {
 772         reply->handle = alloc_handle( current->process, manager, req->access, req->attributes );
 773         release_object( manager );
 774     }
 775 }
 776
 777
 778 /* create a device */
 779 DECL_HANDLER(create_device)
 780 {
 781     struct device *device;
 782     struct unicode_str name = get_req_unicode_str();
 783     struct device_manager *manager;
 784     struct object *root = NULL;
 785
 786     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 787                                                              0, &device_manager_ops )))
 788         return;
 789
 790     if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir )))
 791     {
 792         release_object( manager );
 793         return;
 794     }
 795
 796     if ((device = create_device( root, &name, manager, req->attributes )))
 797     {
 798         device->user_ptr = req->user_ptr;
 799         reply->handle = alloc_handle( current->process, device, req->access, req->attributes );
 800         release_object( device );
 801     }
 802
 803     if (root) release_object( root );
 804     release_object( manager );
 805 }
 806
 807
 808 /* delete a device */
 809 DECL_HANDLER(delete_device)
 810 {
 811     struct device *device;
 812
 813     if ((device = (struct device *)get_handle_obj( current->process, req->handle, 0, &device_ops )))
 814     {
 815         delete_device( device );
 816         release_object( device );
 817     }
 818 }
 819
 820
 821 /* retrieve the next pending device irp request */
 822 DECL_HANDLER(get_next_device_request)
 823 {
 824     struct irp_call *irp;
 825     struct device_manager *manager;
 826     struct list *ptr;
 827     struct iosb *iosb;
 828
 829     reply->params.major = IRP_MJ_MAXIMUM_FUNCTION + 1;
 830
 831     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 832                                                              0, &device_manager_ops )))
 833         return;
 834
 835     if (req->prev)
 836     {
 837         if ((irp = (struct irp_call *)get_handle_obj( current->process, req->prev, 0, &irp_call_ops )))
 838         {
 839             set_irp_result( irp, req->status, NULL, 0, 0 );
 840             close_handle( current->process, req->prev );  /* avoid an extra round-trip for close */
 841             release_object( irp );
 842         }
 843         clear_error();
 844     }
 845
 846     if ((ptr = list_head( &manager->requests )))
 847     {
 848         irp = LIST_ENTRY( ptr, struct irp_call, mgr_entry );
 849         if (irp->thread)
 850         {
 851             reply->client_pid = get_process_id( irp->thread->process );
 852             reply->client_tid = get_thread_id( irp->thread );
 853         }
 854         reply->params = irp->params;
 855         iosb = irp->iosb;
 856         reply->in_size = iosb->in_size;
 857         reply->out_size = iosb->out_size;
 858         if (iosb->in_size > get_reply_max_size()) set_error( STATUS_BUFFER_OVERFLOW );
 859         else if (!irp->file || (reply->next = alloc_handle( current->process, irp, 0, 0 )))
 860         {
 861             set_reply_data_ptr( iosb->in_data, iosb->in_size );
 862             iosb->in_data = NULL;
 863             iosb->in_size = 0;
 864             list_remove( &irp->mgr_entry );
 865             list_init( &irp->mgr_entry );
 866             if (!irp->file) release_object( irp ); /* no longer on manager queue */
 867         }
 868     }
 869     else set_error( STATUS_PENDING );
 870
 871     release_object( manager );
 872 }
 873
 874
 875 /* store results of an async irp */
 876 DECL_HANDLER(set_irp_result)
 877 {
 878     struct irp_call *irp;
 879
 880     if ((irp = (struct irp_call *)get_handle_obj( current->process, req->handle, 0, &irp_call_ops )))
 881     {
 882         if (irp->file) set_file_user_ptr( irp->file, req->file_ptr );
 883         set_irp_result( irp, req->status, get_req_data(), get_req_data_size(), req->size );
 884         close_handle( current->process, req->handle );  /* avoid an extra round-trip for close */
 885         release_object( irp );
 886     }
 887 }
 888
 889
 890 /* get kernel pointer from server object */
 891 DECL_HANDLER(get_kernel_object_ptr)
 892 {
 893     struct device_manager *manager;
 894     struct object *object = NULL;
 895
 896     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 897                                                              0, &device_manager_ops )))
 898         return;
 899
 900     if ((object = get_handle_obj( current->process, req->handle, 0, NULL )))
 901     {
 902         reply->user_ptr = get_kernel_object_ptr( manager, object );
 903         release_object( object );
 904     }
 905
 906     release_object( manager );
 907 }
 908
 909
 910 /* associate kernel pointer with server object */
 911 DECL_HANDLER(set_kernel_object_ptr)
 912 {
 913     struct device_manager *manager;
 914     struct object *object = NULL;
 915
 916     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 917                                                              0, &device_manager_ops )))
 918         return;
 919
 920     if (!(object = get_handle_obj( current->process, req->handle, 0, NULL )))
 921     {
 922         release_object( manager );
 923         return;
 924     }
 925
 926     if (!set_kernel_object( manager, object, req->user_ptr ))
 927         set_error( STATUS_INVALID_HANDLE );
 928
 929     release_object( object );
 930     release_object( manager );
 931 }
 932
 933
 934 /* grab server object reference from kernel object pointer */
 935 DECL_HANDLER(grab_kernel_object)
 936 {
 937     struct device_manager *manager;
 938     struct kernel_object *ref;
 939
 940     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 941                                                              0, &device_manager_ops )))
 942         return;
 943
 944     if ((ref = kernel_object_from_ptr( manager, req->user_ptr )) && !ref->owned)
 945         grab_kernel_object( ref );
 946     else
 947         set_error( STATUS_INVALID_HANDLE );
 948
 949     release_object( manager );
 950 }
 951
 952
 953 /* release server object reference from kernel object pointer */
 954 DECL_HANDLER(release_kernel_object)
 955 {
 956     struct device_manager *manager;
 957     struct kernel_object *ref;
 958
 959     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 960                                                              0, &device_manager_ops )))
 961         return;
 962
 963     if ((ref = kernel_object_from_ptr( manager, req->user_ptr )) && ref->owned)
 964     {
 965         ref->owned = 0;
 966         release_object( ref->object );
 967     }
 968     else set_error( STATUS_INVALID_HANDLE );
 969
 970     release_object( manager );
 971 }
 972
 973
 974 /* get handle from kernel object pointer */
 975 DECL_HANDLER(get_kernel_object_handle)
 976 {
 977     struct device_manager *manager;
 978     struct kernel_object *ref;
 979
 980     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 981                                                              0, &device_manager_ops )))
 982         return;
 983
 984     if ((ref = kernel_object_from_ptr( manager, req->user_ptr )))
 985         reply->handle = alloc_handle( current->process, ref->object, req->access, 0 );
 986     else
 987         set_error( STATUS_INVALID_HANDLE );
 988
 989     release_object( manager );
 990 }