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     struct list            entry;         /* entry in device list */
 168     struct list            requests;      /* list of pending irp requests */
 169 };
 170
 171 static void device_file_dump( struct object *obj, int verbose );
 172 static struct fd *device_file_get_fd( struct object *obj );
 173 static void device_file_destroy( struct object *obj );
 174 static enum server_fd_type device_file_get_fd_type( struct fd *fd );
 175 static obj_handle_t device_file_read( struct fd *fd, const async_data_t *async_data, int blocking,
 176                                       file_pos_t pos );
 177 static obj_handle_t device_file_write( struct fd *fd, const async_data_t *async_data, int blocking,
 178                                        file_pos_t pos, data_size_t *written );
 179 static obj_handle_t device_file_flush( struct fd *fd, const async_data_t *async_data, int blocking );
 180 static obj_handle_t device_file_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data,
 181                                        int blocking );
 182
 183 static const struct object_ops device_file_ops =
 184 {
 185     sizeof(struct device_file),       /* size */
 186     device_file_dump,                 /* dump */
 187     no_get_type,                      /* get_type */
 188     add_queue,                        /* add_queue */
 189     remove_queue,                     /* remove_queue */
 190     default_fd_signaled,              /* signaled */
 191     no_satisfied,                     /* satisfied */
 192     no_signal,                        /* signal */
 193     device_file_get_fd,               /* get_fd */
 194     default_fd_map_access,            /* map_access */
 195     default_get_sd,                   /* get_sd */
 196     default_set_sd,                   /* set_sd */
 197     no_lookup_name,                   /* lookup_name */
 198     no_open_file,                     /* open_file */
 199     no_close_handle,                  /* close_handle */
 200     device_file_destroy               /* destroy */
 201 };
 202
 203 static const struct fd_ops device_file_fd_ops =
 204 {
 205     default_fd_get_poll_events,       /* get_poll_events */
 206     default_poll_event,               /* poll_event */
 207     device_file_get_fd_type,          /* get_fd_type */
 208     device_file_read,                 /* read */
 209     device_file_write,                /* write */
 210     device_file_flush,                /* flush */
 211     device_file_ioctl,                /* ioctl */
 212     default_fd_queue_async,           /* queue_async */
 213     default_fd_reselect_async,        /* reselect_async */
 214     default_fd_cancel_async           /* cancel_async */
 215 };
 216
 217
 218 static void irp_call_dump( struct object *obj, int verbose )
 219 {
 220     struct irp_call *irp = (struct irp_call *)obj;
 221     fprintf( stderr, "IRP call file=%p\n", irp->file );
 222 }
 223
 224 static int irp_call_signaled( struct object *obj, struct wait_queue_entry *entry )
 225 {
 226     struct irp_call *irp = (struct irp_call *)obj;
 227
 228     return !irp->file;  /* file is cleared once the irp has completed */
 229 }
 230
 231 static void irp_call_destroy( struct object *obj )
 232 {
 233     struct irp_call *irp = (struct irp_call *)obj;
 234
 235     free( irp->in_data );
 236     free( irp->out_data );
 237     if (irp->async)
 238     {
 239         async_terminate( irp->async, STATUS_CANCELLED );
 240         release_object( irp->async );
 241     }
 242     if (irp->file) release_object( irp->file );
 243     release_object( irp->thread );
 244 }
 245
 246 static struct irp_call *create_irp( struct device_file *file, const irp_params_t *params,
 247                                     const void *in_data, data_size_t in_size, data_size_t out_size )
 248 {
 249     struct irp_call *irp;
 250
 251     if (!file->device->manager)  /* it has been deleted */
 252     {
 253         set_error( STATUS_FILE_DELETED );
 254         return NULL;
 255     }
 256
 257     if ((irp = alloc_object( &irp_call_ops )))
 258     {
 259         irp->file     = (struct device_file *)grab_object( file );
 260         irp->async    = NULL;
 261         irp->params   = *params;
 262         irp->status   = STATUS_PENDING;
 263         irp->result   = 0;
 264         irp->in_size  = in_size;
 265         irp->in_data  = NULL;
 266         irp->out_size = out_size;
 267         irp->out_data = NULL;
 268
 269         if (irp->in_size && !(irp->in_data = memdup( in_data, in_size )))
 270         {
 271             release_object( irp );
 272             irp = NULL;
 273         }
 274     }
 275     return irp;
 276 }
 277
 278 static void set_irp_result( struct irp_call *irp, unsigned int status,
 279                             const void *out_data, data_size_t out_size, data_size_t result )
 280 {
 281     struct device_file *file = irp->file;
 282
 283     if (!file) return;  /* already finished */
 284
 285     /* FIXME: handle the STATUS_PENDING case */
 286     irp->status = status;
 287     irp->result = result;
 288     irp->out_size = min( irp->out_size, out_size );
 289     if (irp->out_size && !(irp->out_data = memdup( out_data, irp->out_size )))
 290         irp->out_size = 0;
 291     release_object( file );
 292     irp->file = NULL;
 293     if (irp->async)
 294     {
 295         if (result) status = STATUS_ALERTED;
 296         async_terminate( irp->async, status );
 297         release_object( irp->async );
 298         irp->async = NULL;
 299     }
 300     wake_up( &irp->obj, 0 );
 301
 302     if (status != STATUS_ALERTED)
 303     {
 304         /* remove it from the device queue */
 305         /* (for STATUS_ALERTED this will be done in get_irp_result) */
 306         list_remove( &irp->dev_entry );
 307         release_object( irp );  /* no longer on the device queue */
 308     }
 309 }
 310
 311
 312 static void device_dump( struct object *obj, int verbose )
 313 {
 314     struct device *device = (struct device *)obj;
 315
 316     fprintf( stderr, "Device " );
 317     dump_object_name( &device->obj );
 318     fputc( '\n', stderr );
 319 }
 320
 321 static struct object_type *device_get_type( struct object *obj )
 322 {
 323     static const WCHAR name[] = {'D','e','v','i','c','e'};
 324     static const struct unicode_str str = { name, sizeof(name) };
 325     return get_object_type( &str );
 326 }
 327
 328 static void device_destroy( struct object *obj )
 329 {
 330     struct device *device = (struct device *)obj;
 331
 332     assert( list_empty( &device->files ));
 333
 334     free( device->unix_path );
 335     if (device->manager) list_remove( &device->entry );
 336 }
 337
 338 static struct object *device_open_file( struct object *obj, unsigned int access,
 339                                         unsigned int sharing, unsigned int options )
 340 {
 341     struct device *device = (struct device *)obj;
 342     struct device_file *file;
 343
 344     if ((file = alloc_object( &device_file_ops )))
 345     {
 346         file->device = (struct device *)grab_object( device );
 347         list_init( &file->requests );
 348         list_add_tail( &device->files, &file->entry );
 349         if (device->unix_path)
 350         {
 351             mode_t mode = 0666;
 352             access = file->obj.ops->map_access( &file->obj, access );
 353             file->fd = open_fd( NULL, device->unix_path, O_NONBLOCK | O_LARGEFILE,
 354                                 &mode, access, sharing, options );
 355             if (file->fd) set_fd_user( file->fd, &device_file_fd_ops, &file->obj );
 356         }
 357         else file->fd = alloc_pseudo_fd( &device_file_fd_ops, &file->obj, 0 );
 358
 359         if (!file->fd)
 360         {
 361             release_object( file );
 362             file = NULL;
 363         }
 364     }
 365     return &file->obj;
 366 }
 367
 368 static void device_file_dump( struct object *obj, int verbose )
 369 {
 370     struct device_file *file = (struct device_file *)obj;
 371
 372     fprintf( stderr, "File on device %p\n", file->device );
 373 }
 374
 375 static struct fd *device_file_get_fd( struct object *obj )
 376 {
 377     struct device_file *file = (struct device_file *)obj;
 378
 379     return (struct fd *)grab_object( file->fd );
 380 }
 381
 382 static void device_file_destroy( struct object *obj )
 383 {
 384     struct device_file *file = (struct device_file *)obj;
 385     struct irp_call *irp, *next;
 386
 387     LIST_FOR_EACH_ENTRY_SAFE( irp, next, &file->requests, struct irp_call, dev_entry )
 388     {
 389         list_remove( &irp->dev_entry );
 390         release_object( irp );  /* no longer on the device queue */
 391     }
 392     if (file->fd) release_object( file->fd );
 393     list_remove( &file->entry );
 394     release_object( file->device );
 395 }
 396
 397 static struct irp_call *find_irp_call( struct device_file *file, struct thread *thread,
 398                                        client_ptr_t user_arg )
 399 {
 400     struct irp_call *irp;
 401
 402     LIST_FOR_EACH_ENTRY( irp, &file->requests, struct irp_call, dev_entry )
 403         if (irp->thread == thread && irp->user_arg == user_arg) return irp;
 404
 405     set_error( STATUS_INVALID_PARAMETER );
 406     return NULL;
 407 }
 408
 409 /* queue an irp to the device */
 410 static obj_handle_t queue_irp( struct device_file *file, struct irp_call *irp,
 411                                const async_data_t *async_data, int blocking )
 412 {
 413     obj_handle_t handle = 0;
 414     struct device_manager *manager = file->device->manager;
 415
 416     assert( manager );
 417
 418     if (blocking && !(handle = alloc_handle( current->process, irp, SYNCHRONIZE, 0 ))) return 0;
 419
 420     if (!(irp->async = fd_queue_async( file->fd, async_data, ASYNC_TYPE_WAIT )))
 421     {
 422         if (handle) close_handle( current->process, handle );
 423         return 0;
 424     }
 425     irp->thread   = (struct thread *)grab_object( current );
 426     irp->user_arg = async_data->arg;
 427     grab_object( irp );  /* grab reference for queued irp */
 428
 429     list_add_tail( &file->requests, &irp->dev_entry );
 430     list_add_tail( &manager->requests, &irp->mgr_entry );
 431     if (list_head( &manager->requests ) == &irp->mgr_entry) wake_up( &manager->obj, 0 );  /* first one */
 432     set_error( STATUS_PENDING );
 433     return handle;
 434 }
 435
 436 static enum server_fd_type device_file_get_fd_type( struct fd *fd )
 437 {
 438     return FD_TYPE_DEVICE;
 439 }
 440
 441 static obj_handle_t device_file_read( struct fd *fd, const async_data_t *async_data, int blocking,
 442                                       file_pos_t pos )
 443 {
 444     struct device_file *file = get_fd_user( fd );
 445     struct irp_call *irp;
 446     obj_handle_t handle;
 447     irp_params_t params;
 448
 449     params.major = IRP_MJ_READ;
 450     params.read.key = 0;
 451     params.read.pos = pos;
 452
 453     irp = create_irp( file, &params, NULL, 0, get_reply_max_size() );
 454     if (!irp) return 0;
 455
 456     handle = queue_irp( file, irp, async_data, blocking );
 457     release_object( irp );
 458     return handle;
 459 }
 460
 461 static obj_handle_t device_file_write( struct fd *fd, const async_data_t *async_data, int blocking,
 462                                        file_pos_t pos, data_size_t *written )
 463 {
 464     struct device_file *file = get_fd_user( fd );
 465     struct irp_call *irp;
 466     obj_handle_t handle;
 467     irp_params_t params;
 468
 469     params.major = IRP_MJ_WRITE;
 470     params.write.key = 0;
 471     params.write.pos = pos;
 472
 473     irp = create_irp( file, &params, get_req_data(), get_req_data_size(), 0 );
 474     if (!irp) return 0;
 475
 476     handle = queue_irp( file, irp, async_data, blocking );
 477     release_object( irp );
 478     return handle;
 479 }
 480
 481 static obj_handle_t device_file_flush( struct fd *fd, const async_data_t *async_data, int blocking )
 482 {
 483     struct device_file *file = get_fd_user( fd );
 484     struct irp_call *irp;
 485     obj_handle_t handle;
 486     irp_params_t params;
 487
 488     params.major = IRP_MJ_FLUSH_BUFFERS;
 489
 490     irp = create_irp( file, &params, NULL, 0, 0 );
 491     if (!irp) return 0;
 492
 493     handle = queue_irp( file, irp, async_data, blocking );
 494     release_object( irp );
 495     return handle;
 496 }
 497
 498 static obj_handle_t device_file_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data,
 499                                        int blocking )
 500 {
 501     struct device_file *file = get_fd_user( fd );
 502     struct irp_call *irp;
 503     obj_handle_t handle;
 504     irp_params_t params;
 505
 506     params.major = IRP_MJ_DEVICE_CONTROL;
 507     params.ioctl.code = code;
 508
 509     irp = create_irp( file, &params, get_req_data(), get_req_data_size(),
 510                       get_reply_max_size() );
 511     if (!irp) return 0;
 512
 513     handle = queue_irp( file, irp, async_data, blocking );
 514     release_object( irp );
 515     return handle;
 516 }
 517
 518 static struct device *create_device( struct directory *root, const struct unicode_str *name,
 519                                      struct device_manager *manager, unsigned int attr )
 520 {
 521     struct device *device;
 522
 523     if ((device = create_named_object_dir( root, name, attr, &device_ops )))
 524     {
 525         if (get_error() != STATUS_OBJECT_NAME_EXISTS)
 526         {
 527             /* initialize it if it didn't already exist */
 528             device->unix_path = NULL;
 529             device->manager = manager;
 530             list_add_tail( &manager->devices, &device->entry );
 531             list_init( &device->files );
 532         }
 533     }
 534     return device;
 535 }
 536
 537 /* terminate requests when the underlying device is deleted */
 538 static void delete_file( struct device_file *file )
 539 {
 540     struct irp_call *irp, *next;
 541
 542     /* terminate all pending requests */
 543     LIST_FOR_EACH_ENTRY_SAFE( irp, next, &file->requests, struct irp_call, dev_entry )
 544     {
 545         list_remove( &irp->mgr_entry );
 546         set_irp_result( irp, STATUS_FILE_DELETED, NULL, 0, 0 );
 547     }
 548 }
 549
 550 static void delete_device( struct device *device )
 551 {
 552     struct device_file *file, *next;
 553
 554     if (!device->manager) return;  /* already deleted */
 555
 556     LIST_FOR_EACH_ENTRY_SAFE( file, next, &device->files, struct device_file, entry )
 557         delete_file( file );
 558
 559     unlink_named_object( &device->obj );
 560     list_remove( &device->entry );
 561     device->manager = NULL;
 562 }
 563
 564
 565 static void device_manager_dump( struct object *obj, int verbose )
 566 {
 567     fprintf( stderr, "Device manager\n" );
 568 }
 569
 570 static int device_manager_signaled( struct object *obj, struct wait_queue_entry *entry )
 571 {
 572     struct device_manager *manager = (struct device_manager *)obj;
 573
 574     return !list_empty( &manager->requests );
 575 }
 576
 577 static void device_manager_destroy( struct object *obj )
 578 {
 579     struct device_manager *manager = (struct device_manager *)obj;
 580     struct list *ptr;
 581
 582     while ((ptr = list_head( &manager->devices )))
 583     {
 584         struct device *device = LIST_ENTRY( ptr, struct device, entry );
 585         delete_device( device );
 586     }
 587 }
 588
 589 static struct device_manager *create_device_manager(void)
 590 {
 591     struct device_manager *manager;
 592
 593     if ((manager = alloc_object( &device_manager_ops )))
 594     {
 595         list_init( &manager->devices );
 596         list_init( &manager->requests );
 597     }
 598     return manager;
 599 }
 600
 601
 602 /* create a device manager */
 603 DECL_HANDLER(create_device_manager)
 604 {
 605     struct device_manager *manager = create_device_manager();
 606
 607     if (manager)
 608     {
 609         reply->handle = alloc_handle( current->process, manager, req->access, req->attributes );
 610         release_object( manager );
 611     }
 612 }
 613
 614
 615 /* create a device */
 616 DECL_HANDLER(create_device)
 617 {
 618     struct device *device;
 619     struct unicode_str name;
 620     struct device_manager *manager;
 621     struct directory *root = NULL;
 622
 623     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 624                                                              0, &device_manager_ops )))
 625         return;
 626
 627     get_req_unicode_str( &name );
 628     if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
 629     {
 630         release_object( manager );
 631         return;
 632     }
 633
 634     if ((device = create_device( root, &name, manager, req->attributes )))
 635     {
 636         device->user_ptr = req->user_ptr;
 637         reply->handle = alloc_handle( current->process, device, req->access, req->attributes );
 638         release_object( device );
 639     }
 640
 641     if (root) release_object( root );
 642     release_object( manager );
 643 }
 644
 645
 646 /* delete a device */
 647 DECL_HANDLER(delete_device)
 648 {
 649     struct device *device;
 650
 651     if ((device = (struct device *)get_handle_obj( current->process, req->handle, 0, &device_ops )))
 652     {
 653         delete_device( device );
 654         release_object( device );
 655     }
 656 }
 657
 658
 659 /* retrieve the next pending device irp request */
 660 DECL_HANDLER(get_next_device_request)
 661 {
 662     struct irp_call *irp;
 663     struct device_manager *manager;
 664     struct list *ptr;
 665
 666     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 667                                                              0, &device_manager_ops )))
 668         return;
 669
 670     if (req->prev)
 671     {
 672         if ((irp = (struct irp_call *)get_handle_obj( current->process, req->prev, 0, &irp_call_ops )))
 673         {
 674             set_irp_result( irp, req->status, NULL, 0, 0 );
 675             close_handle( current->process, req->prev );  /* avoid an extra round-trip for close */
 676             release_object( irp );
 677         }
 678         clear_error();
 679     }
 680
 681     if ((ptr = list_head( &manager->requests )))
 682     {
 683         irp = LIST_ENTRY( ptr, struct irp_call, mgr_entry );
 684         reply->params = irp->params;
 685         reply->user_ptr = irp->file->device->user_ptr;
 686         reply->client_pid = get_process_id( irp->thread->process );
 687         reply->client_tid = get_thread_id( irp->thread );
 688         reply->in_size = irp->in_size;
 689         reply->out_size = irp->out_size;
 690         if (irp->in_size > get_reply_max_size()) set_error( STATUS_BUFFER_OVERFLOW );
 691         else if ((reply->next = alloc_handle( current->process, irp, 0, 0 )))
 692         {
 693             set_reply_data_ptr( irp->in_data, irp->in_size );
 694             irp->in_data = NULL;
 695             irp->in_size = 0;
 696             list_remove( &irp->mgr_entry );
 697             list_init( &irp->mgr_entry );
 698         }
 699     }
 700     else set_error( STATUS_PENDING );
 701
 702     release_object( manager );
 703 }
 704
 705
 706 /* store results of an async irp */
 707 DECL_HANDLER(set_irp_result)
 708 {
 709     struct irp_call *irp;
 710     struct device_manager *manager;
 711
 712     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 713                                                              0, &device_manager_ops )))
 714         return;
 715
 716     if ((irp = (struct irp_call *)get_handle_obj( current->process, req->handle, 0, &irp_call_ops )))
 717     {
 718         set_irp_result( irp, req->status, get_req_data(), get_req_data_size(), req->size );
 719         close_handle( current->process, req->handle );  /* avoid an extra round-trip for close */
 720         release_object( irp );
 721     }
 722     release_object( manager );
 723 }
 724
 725
 726 /* retrieve results of an async irp */
 727 DECL_HANDLER(get_irp_result)
 728 {
 729     struct device_file *file;
 730     struct irp_call *irp;
 731
 732     if (!(file = (struct device_file *)get_handle_obj( current->process, req->handle,
 733                                                        0, &device_file_ops )))
 734         return;
 735
 736     if ((irp = find_irp_call( file, current, req->user_arg )))
 737     {
 738         if (irp->out_data)
 739         {
 740             data_size_t size = min( irp->out_size, get_reply_max_size() );
 741             if (size)
 742             {
 743                 set_reply_data_ptr( irp->out_data, size );
 744                 irp->out_data = NULL;
 745             }
 746         }
 747         reply->size = irp->result;
 748         set_error( irp->status );
 749         list_remove( &irp->dev_entry );
 750         release_object( irp );  /* no longer on the device queue */
 751     }
 752     release_object( file );
 753 }