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 <assert.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <stdarg.h>
  25
  26 #include "ntstatus.h"
  27 #define WIN32_NO_STATUS
  28 #include "windef.h"
  29 #include "winternl.h"
  30 #include "ddk/wdm.h"
  31
  32 #include "object.h"
  33 #include "file.h"
  34 #include "handle.h"
  35 #include "request.h"
  36 #include "process.h"
  37
  38 struct irp_call
  39 {
  40     struct object          obj;           /* object header */
  41     struct list            dev_entry;     /* entry in device queue */
  42     struct list            mgr_entry;     /* entry in manager queue */
  43     struct device         *device;        /* device containing this irp */
  44     struct thread         *thread;        /* thread that queued the irp */
  45     client_ptr_t           user_arg;      /* user arg used to identify the request */
  46     struct async          *async;         /* pending async op */
  47     unsigned int           type;          /* request type (IRP_MJ_*) */
  48     unsigned int           status;        /* resulting status (or STATUS_PENDING) */
  49     ioctl_code_t           code;          /* ioctl code */
  50     data_size_t            in_size;       /* size of input data */
  51     void                  *in_data;       /* input data */
  52     data_size_t            out_size;      /* size of output data */
  53     void                  *out_data;      /* output data */
  54 };
  55
  56 static void irp_call_dump( struct object *obj, int verbose );
  57 static int irp_call_signaled( struct object *obj, struct wait_queue_entry *entry );
  58 static void irp_call_destroy( struct object *obj );
  59
  60 static const struct object_ops irp_call_ops =
  61 {
  62     sizeof(struct irp_call),          /* size */
  63     irp_call_dump,                    /* dump */
  64     no_get_type,                      /* get_type */
  65     add_queue,                        /* add_queue */
  66     remove_queue,                     /* remove_queue */
  67     irp_call_signaled,                /* signaled */
  68     no_satisfied,                     /* satisfied */
  69     no_signal,                        /* signal */
  70     no_get_fd,                        /* get_fd */
  71     no_map_access,                    /* map_access */
  72     default_get_sd,                   /* get_sd */
  73     default_set_sd,                   /* set_sd */
  74     no_lookup_name,                   /* lookup_name */
  75     no_open_file,                     /* open_file */
  76     no_close_handle,                  /* close_handle */
  77     irp_call_destroy                  /* destroy */
  78 };
  79
  80
  81 struct device_manager
  82 {
  83     struct object          obj;           /* object header */
  84     struct list            devices;       /* list of devices */
  85     struct list            requests;      /* list of pending irps across all devices */
  86 };
  87
  88 static void device_manager_dump( struct object *obj, int verbose );
  89 static int device_manager_signaled( struct object *obj, struct wait_queue_entry *entry );
  90 static void device_manager_destroy( struct object *obj );
  91
  92 static const struct object_ops device_manager_ops =
  93 {
  94     sizeof(struct device_manager),    /* size */
  95     device_manager_dump,              /* dump */
  96     no_get_type,                      /* get_type */
  97     add_queue,                        /* add_queue */
  98     remove_queue,                     /* remove_queue */
  99     device_manager_signaled,          /* signaled */
 100     no_satisfied,                     /* satisfied */
 101     no_signal,                        /* signal */
 102     no_get_fd,                        /* get_fd */
 103     no_map_access,                    /* map_access */
 104     default_get_sd,                   /* get_sd */
 105     default_set_sd,                   /* set_sd */
 106     no_lookup_name,                   /* lookup_name */
 107     no_open_file,                     /* open_file */
 108     no_close_handle,                  /* close_handle */
 109     device_manager_destroy            /* destroy */
 110 };
 111
 112
 113 struct device
 114 {
 115     struct object          obj;           /* object header */
 116     struct device_manager *manager;       /* manager for this device (or NULL if deleted) */
 117     struct fd             *fd;            /* file descriptor for irp */
 118     client_ptr_t           user_ptr;      /* opaque ptr for client side */
 119     struct list            entry;         /* entry in device manager list */
 120     struct list            requests;      /* list of pending irp requests */
 121 };
 122
 123 static void device_dump( struct object *obj, int verbose );
 124 static struct object_type *device_get_type( struct object *obj );
 125 static struct fd *device_get_fd( struct object *obj );
 126 static void device_destroy( struct object *obj );
 127 static struct object *device_open_file( struct object *obj, unsigned int access,
 128                                         unsigned int sharing, unsigned int options );
 129 static enum server_fd_type device_get_fd_type( struct fd *fd );
 130 static obj_handle_t device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data,
 131                                   int blocking );
 132
 133 static const struct object_ops device_ops =
 134 {
 135     sizeof(struct device),            /* size */
 136     device_dump,                      /* dump */
 137     device_get_type,                  /* get_type */
 138     no_add_queue,                     /* add_queue */
 139     NULL,                             /* remove_queue */
 140     NULL,                             /* signaled */
 141     no_satisfied,                     /* satisfied */
 142     no_signal,                        /* signal */
 143     device_get_fd,                    /* get_fd */
 144     default_fd_map_access,            /* map_access */
 145     default_get_sd,                   /* get_sd */
 146     default_set_sd,                   /* set_sd */
 147     no_lookup_name,                   /* lookup_name */
 148     device_open_file,                 /* open_file */
 149     no_close_handle,                  /* close_handle */
 150     device_destroy                    /* destroy */
 151 };
 152
 153 static const struct fd_ops device_fd_ops =
 154 {
 155     default_fd_get_poll_events,       /* get_poll_events */
 156     default_poll_event,               /* poll_event */
 157     no_flush,                         /* flush */
 158     device_get_fd_type,               /* get_fd_type */
 159     device_ioctl,                     /* ioctl */
 160     default_fd_queue_async,           /* queue_async */
 161     default_fd_reselect_async,        /* reselect_async */
 162     default_fd_cancel_async           /* cancel_async */
 163 };
 164
 165
 166 static void irp_call_dump( struct object *obj, int verbose )
 167 {
 168     struct irp_call *irp = (struct irp_call *)obj;
 169     fprintf( stderr, "IRP call device=%p\n", irp->device );
 170 }
 171
 172 static int irp_call_signaled( struct object *obj, struct wait_queue_entry *entry )
 173 {
 174     struct irp_call *irp = (struct irp_call *)obj;
 175
 176     return !irp->device;  /* device is cleared once the irp has completed */
 177 }
 178
 179 static void irp_call_destroy( struct object *obj )
 180 {
 181     struct irp_call *irp = (struct irp_call *)obj;
 182
 183     free( irp->in_data );
 184     free( irp->out_data );
 185     if (irp->async)
 186     {
 187         async_terminate( irp->async, STATUS_CANCELLED );
 188         release_object( irp->async );
 189     }
 190     if (irp->device) release_object( irp->device );
 191     release_object( irp->thread );
 192 }
 193
 194 static struct irp_call *create_irp( struct device *device, unsigned int type, const void *in_data,
 195                                     data_size_t in_size, data_size_t out_size )
 196 {
 197     struct irp_call *irp;
 198
 199     if ((irp = alloc_object( &irp_call_ops )))
 200     {
 201         irp->device   = (struct device *)grab_object( device );
 202         irp->async    = NULL;
 203         irp->type     = type;
 204         irp->code     = 0;
 205         irp->status   = STATUS_PENDING;
 206         irp->in_size  = in_size;
 207         irp->in_data  = NULL;
 208         irp->out_size = out_size;
 209         irp->out_data = NULL;
 210
 211         if (irp->in_size && !(irp->in_data = memdup( in_data, in_size )))
 212         {
 213             release_object( irp );
 214             irp = NULL;
 215         }
 216     }
 217     return irp;
 218 }
 219
 220 static void set_irp_result( struct irp_call *irp, unsigned int status,
 221                             const void *out_data, data_size_t out_size )
 222 {
 223     struct device *device = irp->device;
 224
 225     if (!device) return;  /* already finished */
 226
 227     /* FIXME: handle the STATUS_PENDING case */
 228     irp->status = status;
 229     irp->out_size = min( irp->out_size, out_size );
 230     if (irp->out_size && !(irp->out_data = memdup( out_data, irp->out_size )))
 231         irp->out_size = 0;
 232     release_object( device );
 233     irp->device = NULL;
 234     if (irp->async)
 235     {
 236         if (irp->out_size) status = STATUS_ALERTED;
 237         async_terminate( irp->async, status );
 238         release_object( irp->async );
 239         irp->async = NULL;
 240     }
 241     wake_up( &irp->obj, 0 );
 242
 243     if (status != STATUS_ALERTED)
 244     {
 245         /* remove it from the device queue */
 246         /* (for STATUS_ALERTED this will be done in get_irp_result) */
 247         list_remove( &irp->dev_entry );
 248         release_object( irp );  /* no longer on the device queue */
 249     }
 250 }
 251
 252
 253 static void device_dump( struct object *obj, int verbose )
 254 {
 255     struct device *device = (struct device *)obj;
 256
 257     fprintf( stderr, "Device " );
 258     dump_object_name( &device->obj );
 259     fputc( '\n', stderr );
 260 }
 261
 262 static struct object_type *device_get_type( struct object *obj )
 263 {
 264     static const WCHAR name[] = {'D','e','v','i','c','e'};
 265     static const struct unicode_str str = { name, sizeof(name) };
 266     return get_object_type( &str );
 267 }
 268
 269 static struct fd *device_get_fd( struct object *obj )
 270 {
 271     struct device *device = (struct device *)obj;
 272
 273     return (struct fd *)grab_object( device->fd );
 274 }
 275
 276 static void device_destroy( struct object *obj )
 277 {
 278     struct device *device = (struct device *)obj;
 279     struct irp_call *irp, *next;
 280
 281     LIST_FOR_EACH_ENTRY_SAFE( irp, next, &device->requests, struct irp_call, dev_entry )
 282     {
 283         list_remove( &irp->dev_entry );
 284         release_object( irp );  /* no longer on the device queue */
 285     }
 286     if (device->fd) release_object( device->fd );
 287     if (device->manager) list_remove( &device->entry );
 288 }
 289
 290 static struct object *device_open_file( struct object *obj, unsigned int access,
 291                                         unsigned int sharing, unsigned int options )
 292 {
 293     return grab_object( obj );
 294 }
 295
 296 static enum server_fd_type device_get_fd_type( struct fd *fd )
 297 {
 298     return FD_TYPE_DEVICE;
 299 }
 300
 301 static struct irp_call *find_irp_call( struct device *device, struct thread *thread,
 302                                        client_ptr_t user_arg )
 303 {
 304     struct irp_call *irp;
 305
 306     LIST_FOR_EACH_ENTRY( irp, &device->requests, struct irp_call, dev_entry )
 307         if (irp->thread == thread && irp->user_arg == user_arg) return irp;
 308
 309     set_error( STATUS_INVALID_PARAMETER );
 310     return NULL;
 311 }
 312
 313 static obj_handle_t device_ioctl( struct fd *fd, ioctl_code_t code, const async_data_t *async_data,
 314                                   int blocking )
 315 {
 316     struct device *device = get_fd_user( fd );
 317     struct irp_call *irp;
 318     obj_handle_t handle = 0;
 319
 320     if (!device->manager)  /* it has been deleted */
 321     {
 322         set_error( STATUS_FILE_DELETED );
 323         return 0;
 324     }
 325
 326     if (!(irp = create_irp( device, IRP_MJ_DEVICE_CONTROL, get_req_data(), get_req_data_size(),
 327                             get_reply_max_size() )))
 328         return 0;
 329
 330     irp->code     = code;
 331     irp->thread   = (struct thread *)grab_object( current );
 332     irp->user_arg = async_data->arg;
 333
 334     if (blocking && !(handle = alloc_handle( current->process, irp, SYNCHRONIZE, 0 )))
 335     {
 336         release_object( irp );
 337         return 0;
 338     }
 339
 340     if (!(irp->async = fd_queue_async( device->fd, async_data, ASYNC_TYPE_WAIT )))
 341     {
 342         if (handle) close_handle( current->process, handle );
 343         release_object( irp );
 344         return 0;
 345     }
 346     list_add_tail( &device->requests, &irp->dev_entry );
 347     list_add_tail( &device->manager->requests, &irp->mgr_entry );
 348     if (list_head( &device->manager->requests ) == &irp->mgr_entry)  /* first one */
 349         wake_up( &device->manager->obj, 0 );
 350     /* don't release irp since it is now queued in the device */
 351     set_error( STATUS_PENDING );
 352     return handle;
 353 }
 354
 355 static struct device *create_device( struct directory *root, const struct unicode_str *name,
 356                                      struct device_manager *manager, unsigned int attr )
 357 {
 358     struct device *device;
 359
 360     if ((device = create_named_object_dir( root, name, attr, &device_ops )))
 361     {
 362         if (get_error() != STATUS_OBJECT_NAME_EXISTS)
 363         {
 364             /* initialize it if it didn't already exist */
 365             device->manager = manager;
 366             list_add_tail( &manager->devices, &device->entry );
 367             list_init( &device->requests );
 368             if (!(device->fd = alloc_pseudo_fd( &device_fd_ops, &device->obj, 0 )))
 369             {
 370                 release_object( device );
 371                 device = NULL;
 372             }
 373         }
 374     }
 375     return device;
 376 }
 377
 378 static void delete_device( struct device *device )
 379 {
 380     struct irp_call *irp, *next;
 381
 382     if (!device->manager) return;  /* already deleted */
 383
 384     /* terminate all pending requests */
 385     LIST_FOR_EACH_ENTRY_SAFE( irp, next, &device->requests, struct irp_call, dev_entry )
 386     {
 387         list_remove( &irp->mgr_entry );
 388         set_irp_result( irp, STATUS_FILE_DELETED, NULL, 0 );
 389     }
 390     unlink_named_object( &device->obj );
 391     list_remove( &device->entry );
 392     device->manager = NULL;
 393 }
 394
 395
 396 static void device_manager_dump( struct object *obj, int verbose )
 397 {
 398     fprintf( stderr, "Device manager\n" );
 399 }
 400
 401 static int device_manager_signaled( struct object *obj, struct wait_queue_entry *entry )
 402 {
 403     struct device_manager *manager = (struct device_manager *)obj;
 404
 405     return !list_empty( &manager->requests );
 406 }
 407
 408 static void device_manager_destroy( struct object *obj )
 409 {
 410     struct device_manager *manager = (struct device_manager *)obj;
 411     struct list *ptr;
 412
 413     while ((ptr = list_head( &manager->devices )))
 414     {
 415         struct device *device = LIST_ENTRY( ptr, struct device, entry );
 416         delete_device( device );
 417     }
 418 }
 419
 420 static struct device_manager *create_device_manager(void)
 421 {
 422     struct device_manager *manager;
 423
 424     if ((manager = alloc_object( &device_manager_ops )))
 425     {
 426         list_init( &manager->devices );
 427         list_init( &manager->requests );
 428     }
 429     return manager;
 430 }
 431
 432
 433 /* create a device manager */
 434 DECL_HANDLER(create_device_manager)
 435 {
 436     struct device_manager *manager = create_device_manager();
 437
 438     if (manager)
 439     {
 440         reply->handle = alloc_handle( current->process, manager, req->access, req->attributes );
 441         release_object( manager );
 442     }
 443 }
 444
 445
 446 /* create a device */
 447 DECL_HANDLER(create_device)
 448 {
 449     struct device *device;
 450     struct unicode_str name;
 451     struct device_manager *manager;
 452     struct directory *root = NULL;
 453
 454     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 455                                                              0, &device_manager_ops )))
 456         return;
 457
 458     get_req_unicode_str( &name );
 459     if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
 460     {
 461         release_object( manager );
 462         return;
 463     }
 464
 465     if ((device = create_device( root, &name, manager, req->attributes )))
 466     {
 467         device->user_ptr = req->user_ptr;
 468         reply->handle = alloc_handle( current->process, device, req->access, req->attributes );
 469         release_object( device );
 470     }
 471
 472     if (root) release_object( root );
 473     release_object( manager );
 474 }
 475
 476
 477 /* delete a device */
 478 DECL_HANDLER(delete_device)
 479 {
 480     struct device *device;
 481
 482     if ((device = (struct device *)get_handle_obj( current->process, req->handle, 0, &device_ops )))
 483     {
 484         delete_device( device );
 485         release_object( device );
 486     }
 487 }
 488
 489
 490 /* retrieve the next pending device irp request */
 491 DECL_HANDLER(get_next_device_request)
 492 {
 493     struct irp_call *irp;
 494     struct device_manager *manager;
 495     struct list *ptr;
 496
 497     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 498                                                              0, &device_manager_ops )))
 499         return;
 500
 501     if (req->prev)
 502     {
 503         if ((irp = (struct irp_call *)get_handle_obj( current->process, req->prev,
 504                                                           0, &irp_call_ops )))
 505         {
 506             set_irp_result( irp, req->status, NULL, 0 );
 507             close_handle( current->process, req->prev );  /* avoid an extra round-trip for close */
 508             release_object( irp );
 509         }
 510         clear_error();
 511     }
 512
 513     if ((ptr = list_head( &manager->requests )))
 514     {
 515         irp = LIST_ENTRY( ptr, struct irp_call, mgr_entry );
 516         reply->type = irp->type;
 517         reply->code = irp->code;
 518         reply->user_ptr = irp->device->user_ptr;
 519         reply->client_pid = get_process_id( irp->thread->process );
 520         reply->client_tid = get_thread_id( irp->thread );
 521         reply->in_size = irp->in_size;
 522         reply->out_size = irp->out_size;
 523         if (irp->in_size > get_reply_max_size()) set_error( STATUS_BUFFER_OVERFLOW );
 524         else if ((reply->next = alloc_handle( current->process, irp, 0, 0 )))
 525         {
 526             set_reply_data_ptr( irp->in_data, irp->in_size );
 527             irp->in_data = NULL;
 528             irp->in_size = 0;
 529             list_remove( &irp->mgr_entry );
 530             list_init( &irp->mgr_entry );
 531         }
 532     }
 533     else set_error( STATUS_PENDING );
 534
 535     release_object( manager );
 536 }
 537
 538
 539 /* store results of an async irp */
 540 DECL_HANDLER(set_irp_result)
 541 {
 542     struct irp_call *irp;
 543     struct device_manager *manager;
 544
 545     if (!(manager = (struct device_manager *)get_handle_obj( current->process, req->manager,
 546                                                              0, &device_manager_ops )))
 547         return;
 548
 549     if ((irp = (struct irp_call *)get_handle_obj( current->process, req->handle, 0, &irp_call_ops )))
 550     {
 551         set_irp_result( irp, req->status, get_req_data(), get_req_data_size() );
 552         close_handle( current->process, req->handle );  /* avoid an extra round-trip for close */
 553         release_object( irp );
 554     }
 555     release_object( manager );
 556 }
 557
 558
 559 /* retrieve results of an async irp */
 560 DECL_HANDLER(get_irp_result)
 561 {
 562     struct device *device;
 563     struct irp_call *irp;
 564
 565     if (!(device = (struct device *)get_handle_obj( current->process, req->handle, 0, &device_ops )))
 566         return;
 567
 568     if ((irp = find_irp_call( device, current, req->user_arg )))
 569     {
 570         if (irp->out_data)
 571         {
 572             data_size_t size = min( irp->out_size, get_reply_max_size() );
 573             if (size)
 574             {
 575                 set_reply_data_ptr( irp->out_data, size );
 576                 irp->out_data = NULL;
 577             }
 578         }
 579         set_error( irp->status );
 580         list_remove( &irp->dev_entry );
 581         release_object( irp );  /* no longer on the device queue */
 582     }
 583     release_object( device );
 584 }