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