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     irp->file = NULL;
 292     if (irp->async)
 293     {
 294         if (result) status = STATUS_ALERTED;
 295         async_terminate( irp->async, status );
 296         release_object( irp->async );
 297         irp->async = NULL;
 298     }
 299     wake_up( &irp->obj, 0 );
 300
 301     if (status != STATUS_ALERTED)
 302     {
 303         /* remove it from the device queue */
 304         /* (for STATUS_ALERTED this will be done in get_irp_result) */
 305         list_remove( &irp->dev_entry );
 306         release_object( irp );  /* no longer on the device queue */
 307     }
 308     release_object( file );
 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 struct device *create_unix_device( struct directory *root, const struct unicode_str *name,
 538                                    const char *unix_path )
 539 {
 540     struct device *device;
 541
 542     if ((device = create_named_object_dir( root, name, 0, &device_ops )))
 543     {
 544         device->unix_path = strdup( unix_path );
 545         device->manager = NULL;  /* no manager, requests go straight to the Unix device */
 546         list_init( &device->files );
 547         make_object_static( &device->obj );
 548     }
 549     return device;
 550
 551 }
 552
 553 /* terminate requests when the underlying device is deleted */
 554 static void delete_file( struct device_file *file )
 555 {
 556     struct irp_call *irp, *next;
 557
 558     /* terminate all pending requests */
 559     LIST_FOR_EACH_ENTRY_SAFE( irp, next, &file->requests, struct irp_call, dev_entry )
 560     {
 561         list_remove( &irp->mgr_entry );
 562         set_irp_result( irp, STATUS_FILE_DELETED, NULL, 0, 0 );
 563     }
 564 }
 565
 566 static void delete_device( struct device *device )
 567 {
 568     struct device_file *file, *next;
 569
 570     if (!device->manager) return;  /* already deleted */
 571
 572     LIST_FOR_EACH_ENTRY_SAFE( file, next, &device->files, struct device_file, entry )
 573         delete_file( file );
 574
 575     unlink_named_object( &device->obj );
 576     list_remove( &device->entry );
 577     device->manager = NULL;
 578 }
 579
 580
 581 static void device_manager_dump( struct object *obj, int verbose )
 582 {
 583     fprintf( stderr, "Device manager\n" );
 584 }
 585
 586 static int device_manager_signaled( struct object *obj, struct wait_queue_entry *entry )
 587 {
 588     struct device_manager *manager = (struct device_manager *)obj;
 589
 590     return !list_empty( &manager->requests );
 591 }
 592
 593 static void device_manager_destroy( struct object *obj )
 594 {
 595     struct device_manager *manager = (struct device_manager *)obj;
 596     struct list *ptr;
 597
 598     while ((ptr = list_head( &manager->devices )))
 599     {
 600         struct device *device = LIST_ENTRY( ptr, struct device, entry );
 601         delete_device( device );
 602     }
 603 }
 604
 605 static struct device_manager *create_device_manager(void)
 606 {
 607     struct device_manager *manager;
 608
 609     if ((manager = alloc_object( &device_manager_ops )))
 610     {
 611         list_init( &manager->devices );
 612         list_init( &manager->requests );
 613     }
 614     return manager;
 615 }
 616
 617
 618 /* create a device manager */
 619 DECL_HANDLER(create_device_manager)
 620 {
 621     struct device_manager *manager = create_device_manager();
 622
 623     if (manager)
 624     {
 625         reply->handle = alloc_handle( current->process, manager, req->access, req->attributes );
 626         release_object( manager );
 627     }
 628 }
 629
 630
 631 /* create a device */
 632 DECL_HANDLER(create_device)
 633 {
 634     struct device *device;
 635     struct unicode_str name;
 636     struct device_manager *manager;
 637     struct directory *root = NULL;
 638
 639     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 640                                                              0, &device_manager_ops )))
 641         return;
 642
 643     get_req_unicode_str( &name );
 644     if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
 645     {
 646         release_object( manager );
 647         return;
 648     }
 649
 650     if ((device = create_device( root, &name, manager, req->attributes )))
 651     {
 652         device->user_ptr = req->user_ptr;
 653         reply->handle = alloc_handle( current->process, device, req->access, req->attributes );
 654         release_object( device );
 655     }
 656
 657     if (root) release_object( root );
 658     release_object( manager );
 659 }
 660
 661
 662 /* delete a device */
 663 DECL_HANDLER(delete_device)
 664 {
 665     struct device *device;
 666
 667     if ((device = (struct device *)get_handle_obj( current->process, req->handle, 0, &device_ops )))
 668     {
 669         delete_device( device );
 670         release_object( device );
 671     }
 672 }
 673
 674
 675 /* retrieve the next pending device irp request */
 676 DECL_HANDLER(get_next_device_request)
 677 {
 678     struct irp_call *irp;
 679     struct device_manager *manager;
 680     struct list *ptr;
 681
 682     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 683                                                              0, &device_manager_ops )))
 684         return;
 685
 686     if (req->prev)
 687     {
 688         if ((irp = (struct irp_call *)get_handle_obj( current->process, req->prev, 0, &irp_call_ops )))
 689         {
 690             set_irp_result( irp, req->status, NULL, 0, 0 );
 691             close_handle( current->process, req->prev );  /* avoid an extra round-trip for close */
 692             release_object( irp );
 693         }
 694         clear_error();
 695     }
 696
 697     if ((ptr = list_head( &manager->requests )))
 698     {
 699         irp = LIST_ENTRY( ptr, struct irp_call, mgr_entry );
 700         reply->params = irp->params;
 701         reply->user_ptr = irp->file->device->user_ptr;
 702         reply->client_pid = get_process_id( irp->thread->process );
 703         reply->client_tid = get_thread_id( irp->thread );
 704         reply->in_size = irp->in_size;
 705         reply->out_size = irp->out_size;
 706         if (irp->in_size > get_reply_max_size()) set_error( STATUS_BUFFER_OVERFLOW );
 707         else if ((reply->next = alloc_handle( current->process, irp, 0, 0 )))
 708         {
 709             set_reply_data_ptr( irp->in_data, irp->in_size );
 710             irp->in_data = NULL;
 711             irp->in_size = 0;
 712             list_remove( &irp->mgr_entry );
 713             list_init( &irp->mgr_entry );
 714         }
 715     }
 716     else set_error( STATUS_PENDING );
 717
 718     release_object( manager );
 719 }
 720
 721
 722 /* store results of an async irp */
 723 DECL_HANDLER(set_irp_result)
 724 {
 725     struct irp_call *irp;
 726     struct device_manager *manager;
 727
 728     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 729                                                              0, &device_manager_ops )))
 730         return;
 731
 732     if ((irp = (struct irp_call *)get_handle_obj( current->process, req->handle, 0, &irp_call_ops )))
 733     {
 734         set_irp_result( irp, req->status, get_req_data(), get_req_data_size(), req->size );
 735         close_handle( current->process, req->handle );  /* avoid an extra round-trip for close */
 736         release_object( irp );
 737     }
 738     release_object( manager );
 739 }
 740
 741
 742 /* retrieve results of an async irp */
 743 DECL_HANDLER(get_irp_result)
 744 {
 745     struct device_file *file;
 746     struct irp_call *irp;
 747
 748     if (!(file = (struct device_file *)get_handle_obj( current->process, req->handle,
 749                                                        0, &device_file_ops )))
 750         return;
 751
 752     if ((irp = find_irp_call( file, current, req->user_arg )))
 753     {
 754         if (irp->out_data)
 755         {
 756             data_size_t size = min( irp->out_size, get_reply_max_size() );
 757             if (size)
 758             {
 759                 set_reply_data_ptr( irp->out_data, size );
 760                 irp->out_data = NULL;
 761             }
 762         }
 763         reply->size = irp->result;
 764         set_error( irp->status );
 765         list_remove( &irp->dev_entry );
 766         release_object( irp );  /* no longer on the device queue */
 767     }
 768     release_object( file );
 769 }