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