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     int                    canceled;      /* the call was canceled */
  56     client_ptr_t           user_ptr;      /* client side pointer */
  57 };
  58
  59 static void irp_call_dump( struct object *obj, int verbose );
  60 static void irp_call_destroy( struct object *obj );
  61
  62 static const struct object_ops irp_call_ops =
  63 {
  64     sizeof(struct irp_call),          /* size */
  65     &no_type,                         /* type */
  66     irp_call_dump,                    /* dump */
  67     no_add_queue,                     /* add_queue */
  68     NULL,                             /* remove_queue */
  69     NULL,                             /* signaled */
  70     NULL,                             /* satisfied */
  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 */
  84 };
  85
  86
  87 /* device manager (a list of devices managed by the same client process) */
  88
  89 struct device_manager
  90 {
  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 */
  96 };
  97
  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 );
 101
 102 static const struct object_ops device_manager_ops =
 103 {
 104     sizeof(struct device_manager),    /* size */
 105     &no_type,                         /* type */
 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 */
 124 };
 125
 126
 127 /* device (a single device object) */
 128
 129 static const WCHAR device_name[] = {'D','e','v','i','c','e'};
 130
 131 struct type_descr device_type =
 132 {
 133     { device_name, sizeof(device_name) },   /* name */
 134     FILE_ALL_ACCESS,                        /* valid_access */
 135     {                                       /* mapping */
 136         FILE_GENERIC_READ,
 137         FILE_GENERIC_WRITE,
 138         FILE_GENERIC_EXECUTE,
 139         FILE_ALL_ACCESS
 140     },
 141 };
 142
 143 struct device
 144 {
 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 */
 151 };
 152
 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 );
 158
 159 static const struct object_ops device_ops =
 160 {
 161     sizeof(struct device),            /* size */
 162     &device_type,                     /* type */
 163     device_dump,                      /* dump */
 164     no_add_queue,                     /* add_queue */
 165     NULL,                             /* remove_queue */
 166     NULL,                             /* signaled */
 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 */
 181 };
 182
 183
 184 /* device file (an open file handle to a device) */
 185
 186 struct device_file
 187 {
 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 */
 195 };
 196
 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 );
 210
 211 static const struct object_ops device_file_ops =
 212 {
 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 */
 233 };
 234
 235 static const struct fd_ops device_file_fd_ops =
 236 {
 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 */
 249 };
 250
 251
 252 struct list *no_kernel_obj_list( struct object *obj )
 253 {
 254     return NULL;
 255 }
 256
 257 struct kernel_object
 258 {
 259     struct device_manager  *manager;
 260     client_ptr_t            user_ptr;
 261     struct object          *object;
 262     int                     owned;
 263     struct list             list_entry;
 264     struct wine_rb_entry    rb_entry;
 265 };
 266
 267 static int compare_kernel_object( const void *k, const struct wine_rb_entry *entry )
 268 {
 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) );
 271 }
 272
 273 static struct kernel_object *kernel_object_from_obj( struct device_manager *manager, struct object *obj )
 274 {
 275     struct kernel_object *kernel_object;
 276     struct list *list;
 277
 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 )
 280     {
 281         if (kernel_object->manager != manager) continue;
 282         return kernel_object;
 283     }
 284     return NULL;
 285 }
 286
 287 static client_ptr_t get_kernel_object_ptr( struct device_manager *manager, struct object *obj )
 288 {
 289     struct kernel_object *kernel_object = kernel_object_from_obj( manager, obj );
 290     return kernel_object ? kernel_object->user_ptr : 0;
 291 }
 292
 293 static struct kernel_object *set_kernel_object( struct device_manager *manager, struct object *obj, client_ptr_t user_ptr )
 294 {
 295     struct kernel_object *kernel_object;
 296     struct list *list;
 297
 298     if (!(list = obj->ops->get_kernel_obj_list( obj ))) return NULL;
 299
 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;
 305
 306     if (wine_rb_put( &manager->kernel_objects, &user_ptr, &kernel_object->rb_entry ))
 307     {
 308         /* kernel_object pointer already set */
 309         free( kernel_object );
 310         return NULL;
 311     }
 312
 313     list_add_head( list, &kernel_object->list_entry );
 314     return kernel_object;
 315 }
 316
 317 static struct kernel_object *kernel_object_from_ptr( struct device_manager *manager, client_ptr_t client_ptr )
 318 {
 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;
 321 }
 322
 323 static void grab_kernel_object( struct kernel_object *ptr )
 324 {
 325     if (!ptr->owned)
 326     {
 327         grab_object( ptr->object );
 328         ptr->owned = 1;
 329     }
 330 }
 331
 332 static void irp_call_dump( struct object *obj, int verbose )
 333 {
 334     struct irp_call *irp = (struct irp_call *)obj;
 335     fprintf( stderr, "IRP call file=%p\n", irp->file );
 336 }
 337
 338 static void irp_call_destroy( struct object *obj )
 339 {
 340     struct irp_call *irp = (struct irp_call *)obj;
 341
 342     if (irp->async)
 343     {
 344         async_terminate( irp->async, STATUS_CANCELLED );
 345         release_object( irp->async );
 346     }
 347     if (irp->iosb) release_object( irp->iosb );
 348     if (irp->file) release_object( irp->file );
 349     if (irp->thread) release_object( irp->thread );
 350 }
 351
 352 static struct irp_call *create_irp( struct device_file *file, const irp_params_t *params, struct async *async )
 353 {
 354     struct irp_call *irp;
 355
 356     if (file && !file->device->manager)  /* it has been deleted */
 357     {
 358         set_error( STATUS_FILE_DELETED );
 359         return NULL;
 360     }
 361
 362     if ((irp = alloc_object( &irp_call_ops )))
 363     {
 364         irp->file     = file ? (struct device_file *)grab_object( file ) : NULL;
 365         irp->thread   = NULL;
 366         irp->async    = NULL;
 367         irp->params   = *params;
 368         irp->iosb     = NULL;
 369         irp->canceled = 0;
 370         irp->user_ptr = 0;
 371
 372         if (async) irp->iosb = async_get_iosb( async );
 373     }
 374     return irp;
 375 }
 376
 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 )
 379 {
 380     struct device_file *file = irp->file;
 381
 382     if (!file) return;  /* already finished */
 383
 384     /* remove it from the device queue */
 385     list_remove( &irp->dev_entry );
 386     irp->file = NULL;
 387     if (irp->async)
 388     {
 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 );
 392         irp->async = NULL;
 393     }
 394
 395     release_object( irp );  /* no longer on the device queue */
 396     release_object( file );
 397 }
 398
 399
 400 static void device_dump( struct object *obj, int verbose )
 401 {
 402     fputs( "Device\n", stderr );
 403 }
 404
 405 static void device_destroy( struct object *obj )
 406 {
 407     struct device *device = (struct device *)obj;
 408
 409     assert( list_empty( &device->files ));
 410
 411     free( device->unix_path );
 412     if (device->manager) list_remove( &device->entry );
 413 }
 414
 415 static void add_irp_to_queue( struct device_manager *manager, struct irp_call *irp, struct thread *thread )
 416 {
 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 */
 422 }
 423
 424 static struct object *device_open_file( struct object *obj, unsigned int access,
 425                                         unsigned int sharing, unsigned int options )
 426 {
 427     struct device *device = (struct device *)obj;
 428     struct device_file *file;
 429     struct unicode_str nt_name;
 430
 431     if (!(file = alloc_object( &device_file_ops ))) return NULL;
 432
 433     file->device = (struct device *)grab_object( device );
 434     file->closed = 0;
 435     list_init( &file->kernel_object );
 436     list_init( &file->requests );
 437     list_add_tail( &device->files, &file->entry );
 438     if (device->unix_path)
 439     {
 440         mode_t mode = 0666;
 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 );
 446     }
 447     else file->fd = alloc_pseudo_fd( &device_file_fd_ops, &file->obj, options );
 448
 449     if (!file->fd)
 450     {
 451         release_object( file );
 452         return NULL;
 453     }
 454
 455     allow_fd_caching( file->fd );
 456
 457     if (device->manager)
 458     {
 459         struct irp_call *irp;
 460         irp_params_t params;
 461
 462         memset( &params, 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 );
 468
 469         if ((irp = create_irp( file, &params, NULL )))
 470         {
 471             add_irp_to_queue( device->manager, irp, current );
 472             release_object( irp );
 473         }
 474     }
 475     return &file->obj;
 476 }
 477
 478 static struct list *device_get_kernel_obj_list( struct object *obj )
 479 {
 480     struct device *device = (struct device *)obj;
 481     return &device->kernel_object;
 482 }
 483
 484 static void device_file_dump( struct object *obj, int verbose )
 485 {
 486     struct device_file *file = (struct device_file *)obj;
 487
 488     fprintf( stderr, "File on device %p\n", file->device );
 489 }
 490
 491 static struct fd *device_file_get_fd( struct object *obj )
 492 {
 493     struct device_file *file = (struct device_file *)obj;
 494
 495     return (struct fd *)grab_object( file->fd );
 496 }
 497
 498 static WCHAR *device_file_get_full_name( struct object *obj, data_size_t *len )
 499 {
 500     struct device_file *file = (struct device_file *)obj;
 501     return file->device->obj.ops->get_full_name( &file->device->obj, len );
 502 }
 503
 504 static struct list *device_file_get_kernel_obj_list( struct object *obj )
 505 {
 506     struct device_file *file = (struct device_file *)obj;
 507     return &file->kernel_object;
 508 }
 509
 510 static int device_file_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
 511 {
 512     struct device_file *file = (struct device_file *)obj;
 513
 514     if (!file->closed && file->device->manager && obj->handle_count == 1)  /* last handle */
 515     {
 516         struct irp_call *irp;
 517         irp_params_t params;
 518
 519         file->closed = 1;
 520         memset( &params, 0, sizeof(params) );
 521         params.close.type = IRP_CALL_CLOSE;
 522
 523         if ((irp = create_irp( file, &params, NULL )))
 524         {
 525             add_irp_to_queue( file->device->manager, irp, current );
 526             release_object( irp );
 527         }
 528     }
 529     return 1;
 530 }
 531
 532 static void device_file_destroy( struct object *obj )
 533 {
 534     struct device_file *file = (struct device_file *)obj;
 535     struct irp_call *irp, *next;
 536
 537     LIST_FOR_EACH_ENTRY_SAFE( irp, next, &file->requests, struct irp_call, dev_entry )
 538     {
 539         list_remove( &irp->dev_entry );
 540         release_object( irp );  /* no longer on the device queue */
 541     }
 542     if (file->fd) release_object( file->fd );
 543     list_remove( &file->entry );
 544     release_object( file->device );
 545 }
 546
 547 static int fill_irp_params( struct device_manager *manager, struct irp_call *irp, irp_params_t *params )
 548 {
 549     switch (irp->params.type)
 550     {
 551     case IRP_CALL_NONE:
 552     case IRP_CALL_FREE:
 553     case IRP_CALL_CANCEL:
 554         break;
 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;
 559         break;
 560     case IRP_CALL_CLOSE:
 561         irp->params.close.file     = get_kernel_object_ptr( manager, &irp->file->obj );
 562         break;
 563     case IRP_CALL_READ:
 564         irp->params.read.file      = get_kernel_object_ptr( manager, &irp->file->obj );
 565         irp->params.read.out_size  = irp->iosb->out_size;
 566         break;
 567     case IRP_CALL_WRITE:
 568         irp->params.write.file     = get_kernel_object_ptr( manager, &irp->file->obj );
 569         break;
 570     case IRP_CALL_FLUSH:
 571         irp->params.flush.file     = get_kernel_object_ptr( manager, &irp->file->obj );
 572         break;
 573     case IRP_CALL_IOCTL:
 574         irp->params.ioctl.file     = get_kernel_object_ptr( manager, &irp->file->obj );
 575         irp->params.ioctl.out_size = irp->iosb->out_size;
 576         break;
 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;
 580         break;
 581     }
 582
 583     *params = irp->params;
 584     return 1;
 585 }
 586
 587 static void free_irp_params( struct irp_call *irp )
 588 {
 589     switch (irp->params.type)
 590     {
 591     case IRP_CALL_CREATE:
 592         close_handle( current->process, irp->params.create.file );
 593         break;
 594     default:
 595         break;
 596     }
 597 }
 598
 599 /* queue an irp to the device */
 600 static void queue_irp( struct device_file *file, const irp_params_t *params, struct async *async )
 601 {
 602     struct irp_call *irp = create_irp( file, params, async );
 603     if (!irp) return;
 604
 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 );
 610 }
 611
 612 static enum server_fd_type device_file_get_fd_type( struct fd *fd )
 613 {
 614     return FD_TYPE_DEVICE;
 615 }
 616
 617 static void device_file_get_volume_info( struct fd *fd, struct async *async, unsigned int info_class )
 618 {
 619     struct device_file *file = get_fd_user( fd );
 620     irp_params_t params;
 621
 622     memset( &params, 0, sizeof(params) );
 623     params.volume.type = IRP_CALL_VOLUME;
 624     params.volume.info_class = info_class;
 625     queue_irp( file, &params, async );
 626 }
 627
 628 static void device_file_read( struct fd *fd, struct async *async, file_pos_t pos )
 629 {
 630     struct device_file *file = get_fd_user( fd );
 631     irp_params_t params;
 632
 633     memset( &params, 0, sizeof(params) );
 634     params.read.type = IRP_CALL_READ;
 635     params.read.key  = 0;
 636     params.read.pos  = pos;
 637     queue_irp( file, &params, async );
 638 }
 639
 640 static void device_file_write( struct fd *fd, struct async *async, file_pos_t pos )
 641 {
 642     struct device_file *file = get_fd_user( fd );
 643     irp_params_t params;
 644
 645     memset( &params, 0, sizeof(params) );
 646     params.write.type = IRP_CALL_WRITE;
 647     params.write.key  = 0;
 648     params.write.pos  = pos;
 649     queue_irp( file, &params, async );
 650 }
 651
 652 static void device_file_flush( struct fd *fd, struct async *async )
 653 {
 654     struct device_file *file = get_fd_user( fd );
 655     irp_params_t params;
 656
 657     memset( &params, 0, sizeof(params) );
 658     params.flush.type = IRP_CALL_FLUSH;
 659     queue_irp( file, &params, async );
 660 }
 661
 662 static void device_file_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
 663 {
 664     struct device_file *file = get_fd_user( fd );
 665     irp_params_t params;
 666
 667     memset( &params, 0, sizeof(params) );
 668     params.ioctl.type = IRP_CALL_IOCTL;
 669     params.ioctl.code = code;
 670     queue_irp( file, &params, async );
 671 }
 672
 673 static void cancel_irp_call( struct irp_call *irp )
 674 {
 675     struct irp_call *cancel_irp;
 676     irp_params_t params;
 677
 678     irp->canceled = 1;
 679     if (!irp->user_ptr || !irp->file || !irp->file->device->manager) return;
 680
 681     memset( &params, 0, sizeof(params) );
 682     params.cancel.type = IRP_CALL_CANCEL;
 683     params.cancel.irp  = irp->user_ptr;
 684
 685     if ((cancel_irp = create_irp( NULL, &params, NULL )))
 686     {
 687         add_irp_to_queue( irp->file->device->manager, cancel_irp, NULL );
 688         release_object( cancel_irp );
 689     }
 690 }
 691
 692 static void device_file_cancel_async( struct fd *fd, struct async *async )
 693 {
 694     struct device_file *file = get_fd_user( fd );
 695     struct irp_call *irp;
 696
 697     LIST_FOR_EACH_ENTRY( irp, &file->requests, struct irp_call, dev_entry )
 698     {
 699         if (irp->async == async)
 700         {
 701             cancel_irp_call( irp );
 702             return;
 703         }
 704     }
 705 }
 706
 707 static struct device *create_device( struct object *root, const struct unicode_str *name,
 708                                      struct device_manager *manager )
 709 {
 710     struct device *device;
 711
 712     if ((device = create_named_object( root, &device_ops, name, 0, NULL )))
 713     {
 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 );
 720     }
 721     return device;
 722 }
 723
 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 )
 727 {
 728     struct device *device;
 729
 730     if ((device = create_named_object( root, &device_ops, name, attr, sd )))
 731     {
 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 );
 736     }
 737     return &device->obj;
 738
 739 }
 740
 741 /* terminate requests when the underlying device is deleted */
 742 static void delete_file( struct device_file *file )
 743 {
 744     struct irp_call *irp, *next;
 745
 746     /* the pending requests may be the only thing holding a reference to the file */
 747     grab_object( file );
 748
 749     /* terminate all pending requests */
 750     LIST_FOR_EACH_ENTRY_SAFE( irp, next, &file->requests, struct irp_call, dev_entry )
 751     {
 752         list_remove( &irp->mgr_entry );
 753         set_irp_result( irp, STATUS_FILE_DELETED, NULL, 0, 0 );
 754     }
 755
 756     release_object( file );
 757 }
 758
 759 static void delete_device( struct device *device )
 760 {
 761     struct device_file *file, *next;
 762
 763     if (!device->manager) return;  /* already deleted */
 764
 765     LIST_FOR_EACH_ENTRY_SAFE( file, next, &device->files, struct device_file, entry )
 766         delete_file( file );
 767
 768     unlink_named_object( &device->obj );
 769     list_remove( &device->entry );
 770     device->manager = NULL;
 771     release_object( device );
 772 }
 773
 774
 775 static void device_manager_dump( struct object *obj, int verbose )
 776 {
 777     fprintf( stderr, "Device manager\n" );
 778 }
 779
 780 static int device_manager_signaled( struct object *obj, struct wait_queue_entry *entry )
 781 {
 782     struct device_manager *manager = (struct device_manager *)obj;
 783
 784     return !list_empty( &manager->requests );
 785 }
 786
 787 static void device_manager_destroy( struct object *obj )
 788 {
 789     struct device_manager *manager = (struct device_manager *)obj;
 790     struct kernel_object *kernel_object;
 791     struct list *ptr;
 792
 793     if (manager->current_call)
 794     {
 795         release_object( manager->current_call );
 796         manager->current_call = NULL;
 797     }
 798
 799     while (manager->kernel_objects.root)
 800     {
 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 );
 806     }
 807
 808     while ((ptr = list_head( &manager->devices )))
 809     {
 810         struct device *device = LIST_ENTRY( ptr, struct device, entry );
 811         delete_device( device );
 812     }
 813
 814     while ((ptr = list_head( &manager->requests )))
 815     {
 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 );
 820     }
 821 }
 822
 823 static struct device_manager *create_device_manager(void)
 824 {
 825     struct device_manager *manager;
 826
 827     if ((manager = alloc_object( &device_manager_ops )))
 828     {
 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 );
 833     }
 834     return manager;
 835 }
 836
 837 void free_kernel_objects( struct object *obj )
 838 {
 839     struct list *ptr, *list;
 840
 841     if (!(list = obj->ops->get_kernel_obj_list( obj ))) return;
 842
 843     while ((ptr = list_head( list )))
 844     {
 845         struct kernel_object *kernel_object = LIST_ENTRY( ptr, struct kernel_object, list_entry );
 846         struct irp_call *irp;
 847         irp_params_t params;
 848
 849         assert( !kernel_object->owned );
 850
 851         memset( &params, 0, sizeof(params) );
 852         params.free.type = IRP_CALL_FREE;
 853         params.free.obj  = kernel_object->user_ptr;
 854
 855         if ((irp = create_irp( NULL, &params, NULL )))
 856         {
 857             add_irp_to_queue( kernel_object->manager, irp, NULL );
 858             release_object( irp );
 859         }
 860
 861         list_remove( &kernel_object->list_entry );
 862         wine_rb_remove( &kernel_object->manager->kernel_objects, &kernel_object->rb_entry );
 863         free( kernel_object );
 864     }
 865 }
 866
 867
 868 /* create a device manager */
 869 DECL_HANDLER(create_device_manager)
 870 {
 871     struct device_manager *manager = create_device_manager();
 872
 873     if (manager)
 874     {
 875         reply->handle = alloc_handle( current->process, manager, req->access, req->attributes );
 876         release_object( manager );
 877     }
 878 }
 879
 880
 881 /* create a device */
 882 DECL_HANDLER(create_device)
 883 {
 884     struct device *device;
 885     struct unicode_str name = get_req_unicode_str();
 886     struct device_manager *manager;
 887     struct object *root = NULL;
 888
 889     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 890                                                              0, &device_manager_ops )))
 891         return;
 892
 893     if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir )))
 894     {
 895         release_object( manager );
 896         return;
 897     }
 898
 899     if ((device = create_device( root, &name, manager )))
 900     {
 901         struct kernel_object *ptr = set_kernel_object( manager, &device->obj, req->user_ptr );
 902         if (ptr)
 903             grab_kernel_object( ptr );
 904         else
 905             set_error( STATUS_NO_MEMORY );
 906         release_object( device );
 907     }
 908
 909     if (root) release_object( root );
 910     release_object( manager );
 911 }
 912
 913
 914 /* delete a device */
 915 DECL_HANDLER(delete_device)
 916 {
 917     struct device_manager *manager;
 918     struct kernel_object *ref;
 919     struct device *device;
 920
 921     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 922                                                              0, &device_manager_ops )))
 923         return;
 924
 925     if ((ref = kernel_object_from_ptr( manager, req->device )) && ref->object->ops == &device_ops)
 926     {
 927         device = (struct device *)grab_object( ref->object );
 928         delete_device( device );
 929         release_object( device );
 930     }
 931     else set_error( STATUS_INVALID_HANDLE );
 932
 933     release_object( manager );
 934 }
 935
 936
 937 /* retrieve the next pending device irp request */
 938 DECL_HANDLER(get_next_device_request)
 939 {
 940     struct irp_call *irp;
 941     struct device_manager *manager;
 942     struct list *ptr;
 943     struct iosb *iosb;
 944
 945     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 946                                                              0, &device_manager_ops )))
 947         return;
 948
 949     /* process result of previous call */
 950     if (manager->current_call)
 951     {
 952         irp = manager->current_call;
 953         irp->user_ptr = req->user_ptr;
 954
 955         if (irp->async)
 956         {
 957             if (req->pending)
 958                 set_async_pending( irp->async );
 959             async_set_initial_status( irp->async, req->status );
 960
 961             if (req->prev)
 962             {
 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 */
 965             }
 966             else
 967             {
 968                 async_wake_obj( irp->async );
 969                 if (irp->canceled)
 970                 {
 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 );
 974                 }
 975             }
 976         }
 977         else
 978         {
 979             set_irp_result( irp, req->status, NULL, 0, 0 );
 980         }
 981
 982         free_irp_params( irp );
 983         release_object( irp );
 984         manager->current_call = NULL;
 985     }
 986
 987     clear_error();
 988
 989     if ((ptr = list_head( &manager->requests )))
 990     {
 991         struct thread *thread;
 992
 993         irp = LIST_ENTRY( ptr, struct irp_call, mgr_entry );
 994
 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 );
 998
 999         iosb = irp->iosb;
1000         if (iosb)
1001             reply->in_size = iosb->in_size;
1002
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 )))
1006         {
1007             if (fill_irp_params( manager, irp, &reply->params ))
1008             {
1009                 if (iosb)
1010                 {
1011                     set_reply_data_ptr( iosb->in_data, iosb->in_size );
1012                     iosb->in_data = NULL;
1013                     iosb->in_size = 0;
1014                 }
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;
1020             }
1021             else close_handle( current->process, reply->next );
1022         }
1023     }
1024     else set_error( STATUS_PENDING );
1025
1026     release_object( manager );
1027 }
1028
1029
1030 /* store results of an async irp */
1031 DECL_HANDLER(set_irp_result)
1032 {
1033     struct irp_call *irp;
1034
1035     if ((irp = (struct irp_call *)get_handle_obj( current->process, req->handle, 0, &irp_call_ops )))
1036     {
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 );
1040     }
1041 }
1042
1043
1044 /* get kernel pointer from server object */
1045 DECL_HANDLER(get_kernel_object_ptr)
1046 {
1047     struct device_manager *manager;
1048     struct object *object = NULL;
1049
1050     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
1051                                                              0, &device_manager_ops )))
1052         return;
1053
1054     if ((object = get_handle_obj( current->process, req->handle, 0, NULL )))
1055     {
1056         reply->user_ptr = get_kernel_object_ptr( manager, object );
1057         release_object( object );
1058     }
1059
1060     release_object( manager );
1061 }
1062
1063
1064 /* associate kernel pointer with server object */
1065 DECL_HANDLER(set_kernel_object_ptr)
1066 {
1067     struct device_manager *manager;
1068     struct object *object = NULL;
1069
1070     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
1071                                                              0, &device_manager_ops )))
1072         return;
1073
1074     if (!(object = get_handle_obj( current->process, req->handle, 0, NULL )))
1075     {
1076         release_object( manager );
1077         return;
1078     }
1079
1080     if (!set_kernel_object( manager, object, req->user_ptr ))
1081         set_error( STATUS_INVALID_HANDLE );
1082
1083     release_object( object );
1084     release_object( manager );
1085 }
1086
1087
1088 /* grab server object reference from kernel object pointer */
1089 DECL_HANDLER(grab_kernel_object)
1090 {
1091     struct device_manager *manager;
1092     struct kernel_object *ref;
1093
1094     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
1095                                                              0, &device_manager_ops )))
1096         return;
1097
1098     if ((ref = kernel_object_from_ptr( manager, req->user_ptr )) && !ref->owned)
1099         grab_kernel_object( ref );
1100     else
1101         set_error( STATUS_INVALID_HANDLE );
1102
1103     release_object( manager );
1104 }
1105
1106
1107 /* release server object reference from kernel object pointer */
1108 DECL_HANDLER(release_kernel_object)
1109 {
1110     struct device_manager *manager;
1111     struct kernel_object *ref;
1112
1113     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
1114                                                              0, &device_manager_ops )))
1115         return;
1116
1117     if ((ref = kernel_object_from_ptr( manager, req->user_ptr )) && ref->owned)
1118     {
1119         ref->owned = 0;
1120         release_object( ref->object );
1121     }
1122     else set_error( STATUS_INVALID_HANDLE );
1123
1124     release_object( manager );
1125 }
1126
1127
1128 /* get handle from kernel object pointer */
1129 DECL_HANDLER(get_kernel_object_handle)
1130 {
1131     struct device_manager *manager;
1132     struct kernel_object *ref;
1133
1134     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
1135                                                              0, &device_manager_ops )))
1136         return;
1137
1138     if ((ref = kernel_object_from_ptr( manager, req->user_ptr )))
1139         reply->handle = alloc_handle( current->process, ref->object, req->access, 0 );
1140     else
1141         set_error( STATUS_INVALID_HANDLE );
1142
1143     release_object( manager );
1144 }