reactos/ntoskrnl/io/pnpmgr/plugplay.c

   1 /*
   2  * PROJECT:         ReactOS Kernel
   3  * COPYRIGHT:       GPL - See COPYING in the top level directory
   4  * FILE:            ntoskrnl/io/pnpmgr/plugplay.c
   5  * PURPOSE:         Plug-and-play interface routines
   6  * PROGRAMMERS:     Eric Kohl <eric.kohl@t-online.de>
   7  */
   8
   9 /* INCLUDES *****************************************************************/
  10
  11 #include <ntoskrnl.h>
  12 #define NDEBUG
  13 #include <debug.h>
  14
  15 #if defined (ALLOC_PRAGMA)
  16 #pragma alloc_text(INIT, IopInitPlugPlayEvents)
  17 #endif
  18
  19 typedef struct _PNP_EVENT_ENTRY
  20 {
  21     LIST_ENTRY ListEntry;
  22     PLUGPLAY_EVENT_BLOCK Event;
  23 } PNP_EVENT_ENTRY, *PPNP_EVENT_ENTRY;
  24
  25
  26 /* GLOBALS *******************************************************************/
  27
  28 static LIST_ENTRY IopPnpEventQueueHead;
  29 static KEVENT IopPnpNotifyEvent;
  30
  31 /* FUNCTIONS *****************************************************************/
  32
  33 NTSTATUS INIT_FUNCTION
  34 IopInitPlugPlayEvents(VOID)
  35 {
  36     InitializeListHead(&IopPnpEventQueueHead);
  37
  38     KeInitializeEvent(&IopPnpNotifyEvent,
  39                       SynchronizationEvent,
  40                       FALSE);
  41
  42     return STATUS_SUCCESS;
  43 }
  44
  45 NTSTATUS
  46 IopQueueTargetDeviceEvent(const GUID *Guid,
  47                           PUNICODE_STRING DeviceIds)
  48 {
  49     PPNP_EVENT_ENTRY EventEntry;
  50     UNICODE_STRING Copy;
  51     ULONG TotalSize;
  52     NTSTATUS Status;
  53
  54     ASSERT(DeviceIds);
  55
  56     /* Allocate a big enough buffer */
  57     Copy.Length = 0;
  58     Copy.MaximumLength = DeviceIds->Length + sizeof(UNICODE_NULL);
  59     TotalSize =
  60         FIELD_OFFSET(PLUGPLAY_EVENT_BLOCK, TargetDevice.DeviceIds) +
  61         Copy.MaximumLength;
  62
  63     EventEntry = ExAllocatePool(NonPagedPool,
  64                                 TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
  65     if (!EventEntry)
  66         return STATUS_INSUFFICIENT_RESOURCES;
  67
  68     /* Fill the buffer with the event GUID */
  69     RtlCopyMemory(&EventEntry->Event.EventGuid,
  70                   Guid,
  71                   sizeof(GUID));
  72     EventEntry->Event.EventCategory = TargetDeviceChangeEvent;
  73     EventEntry->Event.TotalSize = TotalSize;
  74
  75     /* Fill the device id */
  76     Copy.Buffer = EventEntry->Event.TargetDevice.DeviceIds;
  77     Status = RtlAppendUnicodeStringToString(&Copy, DeviceIds);
  78     if (!NT_SUCCESS(Status))
  79         return Status;
  80
  81     InsertHeadList(&IopPnpEventQueueHead,
  82                    &EventEntry->ListEntry);
  83     KeSetEvent(&IopPnpNotifyEvent,
  84                0,
  85                FALSE);
  86
  87     return STATUS_SUCCESS;
  88 }
  89
  90
  91 /*
  92  * Remove the current PnP event from the tail of the event queue
  93  * and signal IopPnpNotifyEvent if there is yet another event in the queue.
  94  */
  95 static NTSTATUS
  96 IopRemovePlugPlayEvent(VOID)
  97 {
  98     /* Remove a pnp event entry from the tail of the queue */
  99     if (!IsListEmpty(&IopPnpEventQueueHead))
 100     {
 101         ExFreePool(CONTAINING_RECORD(RemoveTailList(&IopPnpEventQueueHead), PNP_EVENT_ENTRY, ListEntry));
 102     }
 103
 104     /* Signal the next pnp event in the queue */
 105     if (!IsListEmpty(&IopPnpEventQueueHead))
 106     {
 107         KeSetEvent(&IopPnpNotifyEvent,
 108                    0,
 109                    FALSE);
 110     }
 111
 112     return STATUS_SUCCESS;
 113 }
 114
 115 static PDEVICE_OBJECT
 116 IopTraverseDeviceNode(PDEVICE_NODE Node, PUNICODE_STRING DeviceInstance)
 117 {
 118     PDEVICE_OBJECT DeviceObject;
 119     PDEVICE_NODE ChildNode;
 120
 121     if (RtlEqualUnicodeString(&Node->InstancePath,
 122                               DeviceInstance, TRUE))
 123     {
 124         ObReferenceObject(Node->PhysicalDeviceObject);
 125         return Node->PhysicalDeviceObject;
 126     }
 127
 128     /* Traversal of all children nodes */
 129     for (ChildNode = Node->Child;
 130          ChildNode != NULL;
 131          ChildNode = ChildNode->Sibling)
 132     {
 133         DeviceObject = IopTraverseDeviceNode(ChildNode, DeviceInstance);
 134         if (DeviceObject != NULL)
 135         {
 136             return DeviceObject;
 137         }
 138     }
 139
 140     return NULL;
 141 }
 142
 143
 144 static PDEVICE_OBJECT
 145 IopGetDeviceObjectFromDeviceInstance(PUNICODE_STRING DeviceInstance)
 146 {
 147     if (IopRootDeviceNode == NULL)
 148         return NULL;
 149
 150     if (DeviceInstance == NULL ||
 151         DeviceInstance->Length == 0)
 152     {
 153         if (IopRootDeviceNode->PhysicalDeviceObject)
 154         {
 155             ObReferenceObject(IopRootDeviceNode->PhysicalDeviceObject);
 156             return IopRootDeviceNode->PhysicalDeviceObject;
 157         }
 158         else
 159             return NULL;
 160     }
 161
 162     return IopTraverseDeviceNode(IopRootDeviceNode, DeviceInstance);
 163
 164 }
 165
 166 static NTSTATUS
 167 IopCaptureUnicodeString(PUNICODE_STRING DstName, PUNICODE_STRING SrcName)
 168 {
 169     NTSTATUS Status = STATUS_SUCCESS;
 170     UNICODE_STRING Name;
 171
 172     Name.Buffer = NULL;
 173     _SEH2_TRY
 174     {
 175         Name.Length = SrcName->Length;
 176         Name.MaximumLength = SrcName->MaximumLength;
 177         if (Name.Length > Name.MaximumLength)
 178         {
 179             Status = STATUS_INVALID_PARAMETER;
 180             _SEH2_LEAVE;
 181         }
 182
 183         if (Name.MaximumLength)
 184         {
 185             ProbeForRead(SrcName->Buffer,
 186                          Name.MaximumLength,
 187                          sizeof(WCHAR));
 188             Name.Buffer = ExAllocatePool(NonPagedPool, Name.MaximumLength);
 189             if (Name.Buffer == NULL)
 190             {
 191                 Status = STATUS_INSUFFICIENT_RESOURCES;
 192                 _SEH2_LEAVE;
 193             }
 194
 195             memcpy(Name.Buffer, SrcName->Buffer, Name.MaximumLength);
 196         }
 197
 198         *DstName = Name;
 199     }
 200     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 201     {
 202         if (Name.Buffer)
 203             ExFreePool(Name.Buffer);
 204         Status = _SEH2_GetExceptionCode();
 205     }
 206     _SEH2_END;
 207
 208     return Status;
 209 }
 210
 211 static NTSTATUS
 212 IopGetDeviceProperty(PPLUGPLAY_CONTROL_PROPERTY_DATA PropertyData)
 213 {
 214     PDEVICE_OBJECT DeviceObject = NULL;
 215     NTSTATUS Status;
 216     UNICODE_STRING DeviceInstance;
 217     ULONG BufferSize;
 218     ULONG Property = 0;
 219     PVOID Buffer;
 220
 221     DPRINT("IopGetDeviceProperty() called\n");
 222     DPRINT("Device name: %wZ\n", &PropertyData->DeviceInstance);
 223
 224     Status = IopCaptureUnicodeString(&DeviceInstance, &PropertyData->DeviceInstance);
 225     if (!NT_SUCCESS(Status))
 226     {
 227         return Status;
 228     }
 229
 230     _SEH2_TRY
 231     {
 232         Property = PropertyData->Property;
 233         BufferSize = PropertyData->BufferSize;
 234         ProbeForWrite(PropertyData->Buffer,
 235                       BufferSize,
 236                       sizeof(UCHAR));
 237     }
 238     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 239     {
 240         ExFreePool(DeviceInstance.Buffer);
 241         _SEH2_YIELD(return _SEH2_GetExceptionCode());
 242     }
 243     _SEH2_END;
 244
 245     /* Get the device object */
 246     DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
 247     ExFreePool(DeviceInstance.Buffer);
 248     if (DeviceObject == NULL)
 249     {
 250         return STATUS_NO_SUCH_DEVICE;
 251     }
 252
 253     Buffer = ExAllocatePool(NonPagedPool, BufferSize);
 254     if (Buffer == NULL)
 255     {
 256         return STATUS_INSUFFICIENT_RESOURCES;
 257     }
 258
 259     Status = IoGetDeviceProperty(DeviceObject,
 260                                  Property,
 261                                  BufferSize,
 262                                  Buffer,
 263                                  &BufferSize);
 264
 265     ObDereferenceObject(DeviceObject);
 266
 267     if (NT_SUCCESS(Status))
 268     {
 269         _SEH2_TRY
 270         {
 271             memcpy(PropertyData->Buffer, Buffer, BufferSize);
 272             PropertyData->BufferSize = BufferSize;
 273         }
 274         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 275         {
 276             Status = _SEH2_GetExceptionCode();
 277         }
 278         _SEH2_END;
 279     }
 280
 281     ExFreePool(Buffer);
 282     return Status;
 283 }
 284
 285
 286 static NTSTATUS
 287 IopGetRelatedDevice(PPLUGPLAY_CONTROL_RELATED_DEVICE_DATA RelatedDeviceData)
 288 {
 289     UNICODE_STRING RootDeviceName;
 290     PDEVICE_OBJECT DeviceObject = NULL;
 291     PDEVICE_NODE DeviceNode = NULL;
 292     PDEVICE_NODE RelatedDeviceNode;
 293     UNICODE_STRING TargetDeviceInstance;
 294     NTSTATUS Status = STATUS_SUCCESS;
 295     ULONG Relation = 0;
 296     ULONG MaximumLength = 0;
 297
 298     DPRINT("IopGetRelatedDevice() called\n");
 299     DPRINT("Device name: %wZ\n", &RelatedDeviceData->TargetDeviceInstance);
 300
 301     Status = IopCaptureUnicodeString(&TargetDeviceInstance, &RelatedDeviceData->TargetDeviceInstance);
 302     if (!NT_SUCCESS(Status))
 303     {
 304         return Status;
 305     }
 306
 307     _SEH2_TRY
 308     {
 309         Relation = RelatedDeviceData->Relation;
 310         MaximumLength = RelatedDeviceData->RelatedDeviceInstanceLength;
 311         ProbeForWrite(RelatedDeviceData->RelatedDeviceInstance,
 312                       MaximumLength,
 313                       sizeof(WCHAR));
 314     }
 315     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 316     {
 317         ExFreePool(TargetDeviceInstance.Buffer);
 318         _SEH2_YIELD(return _SEH2_GetExceptionCode());
 319     }
 320     _SEH2_END;
 321
 322     RtlInitUnicodeString(&RootDeviceName,
 323                          L"HTREE\\ROOT\\0");
 324     if (RtlEqualUnicodeString(&TargetDeviceInstance,
 325                               &RootDeviceName,
 326                               TRUE))
 327     {
 328         DeviceNode = IopRootDeviceNode;
 329         ExFreePool(TargetDeviceInstance.Buffer);
 330     }
 331     else
 332     {
 333         /* Get the device object */
 334         DeviceObject = IopGetDeviceObjectFromDeviceInstance(&TargetDeviceInstance);
 335         ExFreePool(TargetDeviceInstance.Buffer);
 336         if (DeviceObject == NULL)
 337             return STATUS_NO_SUCH_DEVICE;
 338
 339         DeviceNode = ((PEXTENDED_DEVOBJ_EXTENSION)DeviceObject->DeviceObjectExtension)->DeviceNode;
 340     }
 341
 342     switch (Relation)
 343     {
 344         case PNP_GET_PARENT_DEVICE:
 345             RelatedDeviceNode = DeviceNode->Parent;
 346             break;
 347
 348         case PNP_GET_CHILD_DEVICE:
 349             RelatedDeviceNode = DeviceNode->Child;
 350             break;
 351
 352         case PNP_GET_SIBLING_DEVICE:
 353             RelatedDeviceNode = DeviceNode->Sibling;
 354             break;
 355
 356         default:
 357             if (DeviceObject != NULL)
 358             {
 359                 ObDereferenceObject(DeviceObject);
 360             }
 361
 362             return STATUS_INVALID_PARAMETER;
 363     }
 364
 365     if (RelatedDeviceNode == NULL)
 366     {
 367         if (DeviceObject)
 368         {
 369             ObDereferenceObject(DeviceObject);
 370         }
 371
 372         return STATUS_NO_SUCH_DEVICE;
 373     }
 374
 375     if (RelatedDeviceNode->InstancePath.Length > MaximumLength)
 376     {
 377         if (DeviceObject)
 378         {
 379             ObDereferenceObject(DeviceObject);
 380         }
 381
 382         return STATUS_BUFFER_TOO_SMALL;
 383     }
 384
 385     /* Copy related device instance name */
 386     _SEH2_TRY
 387     {
 388         RtlCopyMemory(RelatedDeviceData->RelatedDeviceInstance,
 389                       RelatedDeviceNode->InstancePath.Buffer,
 390                       RelatedDeviceNode->InstancePath.Length);
 391         RelatedDeviceData->RelatedDeviceInstanceLength = RelatedDeviceNode->InstancePath.Length;
 392     }
 393     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 394     {
 395         Status = _SEH2_GetExceptionCode();
 396     }
 397     _SEH2_END;
 398
 399     if (DeviceObject != NULL)
 400     {
 401         ObDereferenceObject(DeviceObject);
 402     }
 403
 404     DPRINT("IopGetRelatedDevice() done\n");
 405
 406     return Status;
 407 }
 408
 409
 410 static NTSTATUS
 411 IopDeviceStatus(PPLUGPLAY_CONTROL_STATUS_DATA StatusData)
 412 {
 413     PDEVICE_OBJECT DeviceObject;
 414     PDEVICE_NODE DeviceNode;
 415     ULONG Operation = 0;
 416     ULONG DeviceStatus = 0;
 417     ULONG DeviceProblem = 0;
 418     UNICODE_STRING DeviceInstance;
 419     NTSTATUS Status;
 420
 421     DPRINT("IopDeviceStatus() called\n");
 422
 423     Status = IopCaptureUnicodeString(&DeviceInstance, &StatusData->DeviceInstance);
 424     if (!NT_SUCCESS(Status))
 425         return Status;
 426     DPRINT("Device name: '%wZ'\n", &DeviceInstance);
 427
 428     _SEH2_TRY
 429     {
 430         Operation = StatusData->Operation;
 431         if (Operation == PNP_SET_DEVICE_STATUS)
 432         {
 433             DeviceStatus = StatusData->DeviceStatus;
 434             DeviceProblem = StatusData->DeviceProblem;
 435         }
 436     }
 437     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 438     {
 439         if (DeviceInstance.Buffer) ExFreePool(DeviceInstance.Buffer);
 440         _SEH2_YIELD(return _SEH2_GetExceptionCode());
 441     }
 442     _SEH2_END;
 443
 444     /* Get the device object */
 445     DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
 446     ExFreePool(DeviceInstance.Buffer);
 447     if (DeviceObject == NULL)
 448         return STATUS_NO_SUCH_DEVICE;
 449
 450     DeviceNode = IopGetDeviceNode(DeviceObject);
 451
 452     switch (Operation)
 453     {
 454         case PNP_GET_DEVICE_STATUS:
 455             DPRINT("Get status data\n");
 456             DeviceStatus = DeviceNode->Flags;
 457             DeviceProblem = DeviceNode->Problem;
 458             break;
 459
 460         case PNP_SET_DEVICE_STATUS:
 461             DPRINT("Set status data\n");
 462             DeviceNode->Flags = DeviceStatus;
 463             DeviceNode->Problem = DeviceProblem;
 464             break;
 465
 466         case PNP_CLEAR_DEVICE_STATUS:
 467             DPRINT1("FIXME: Clear status data!\n");
 468             break;
 469     }
 470
 471     ObDereferenceObject(DeviceObject);
 472
 473     if (Operation == PNP_GET_DEVICE_STATUS)
 474     {
 475         _SEH2_TRY
 476         {
 477             StatusData->DeviceStatus = DeviceStatus;
 478             StatusData->DeviceProblem = DeviceProblem;
 479         }
 480         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 481         {
 482             Status = _SEH2_GetExceptionCode();
 483         }
 484         _SEH2_END;
 485     }
 486
 487     return Status;
 488 }
 489
 490
 491 static NTSTATUS
 492 IopGetDeviceDepth(PPLUGPLAY_CONTROL_DEPTH_DATA DepthData)
 493 {
 494     PDEVICE_OBJECT DeviceObject;
 495     PDEVICE_NODE DeviceNode;
 496     UNICODE_STRING DeviceInstance;
 497     NTSTATUS Status = STATUS_SUCCESS;
 498
 499     DPRINT("IopGetDeviceDepth() called\n");
 500     DPRINT("Device name: %wZ\n", &DepthData->DeviceInstance);
 501
 502     Status = IopCaptureUnicodeString(&DeviceInstance, &DepthData->DeviceInstance);
 503     if (!NT_SUCCESS(Status))
 504     {
 505         return Status;
 506     }
 507
 508     /* Get the device object */
 509     DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
 510     ExFreePool(DeviceInstance.Buffer);
 511     if (DeviceObject == NULL)
 512         return STATUS_NO_SUCH_DEVICE;
 513
 514     DeviceNode = IopGetDeviceNode(DeviceObject);
 515
 516     _SEH2_TRY
 517     {
 518         DepthData->Depth = DeviceNode->Level;
 519     }
 520     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 521     {
 522         Status = _SEH2_GetExceptionCode();
 523     }
 524     _SEH2_END;
 525
 526     ObDereferenceObject(DeviceObject);
 527
 528     return Status;
 529 }
 530
 531
 532 static NTSTATUS
 533 IopResetDevice(PPLUGPLAY_CONTROL_RESET_DEVICE_DATA ResetDeviceData)
 534 {
 535     PDEVICE_OBJECT DeviceObject;
 536     PDEVICE_NODE DeviceNode;
 537     NTSTATUS Status = STATUS_SUCCESS;
 538     UNICODE_STRING DeviceInstance;
 539
 540     Status = IopCaptureUnicodeString(&DeviceInstance, &ResetDeviceData->DeviceInstance);
 541     if (!NT_SUCCESS(Status))
 542         return Status;
 543
 544     DPRINT("IopResetDevice(%wZ)\n", &DeviceInstance);
 545
 546     /* Get the device object */
 547     DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
 548     ExFreePool(DeviceInstance.Buffer);
 549     if (DeviceObject == NULL)
 550         return STATUS_NO_SUCH_DEVICE;
 551
 552     /* Get the device node */
 553     DeviceNode = IopGetDeviceNode(DeviceObject);
 554
 555     ASSERT(DeviceNode->Flags & DNF_ENUMERATED);
 556     ASSERT(DeviceNode->Flags & DNF_PROCESSED);
 557
 558     /* Check if there's already a driver loaded for this device */
 559     if (DeviceNode->Flags & DNF_ADDED)
 560     {
 561         /* Remove the device node */
 562         Status = IopRemoveDevice(DeviceNode);
 563         if (NT_SUCCESS(Status))
 564         {
 565             /* Invalidate device relations for the parent to reenumerate the device */
 566             Status = IoSynchronousInvalidateDeviceRelations(DeviceNode->Parent->PhysicalDeviceObject, BusRelations);
 567             DPRINT1("A new driver has been loaded for '%wZ' (FDO above removed)\n", &DeviceNode->InstancePath);
 568         }
 569         else
 570         {
 571             /* A driver has already been loaded for this device */
 572             DPRINT1("A reboot is required for the current driver for '%wZ' to be replaced\n", &DeviceNode->InstancePath);
 573         }
 574     }
 575     else
 576     {
 577         /* FIXME: What if the device really is disabled? */
 578         DeviceNode->Flags &= ~DNF_DISABLED;
 579
 580         /* Load service data from the registry */
 581         Status = IopActionConfigureChildServices(DeviceNode, DeviceNode->Parent);
 582
 583         if (NT_SUCCESS(Status))
 584         {
 585             /* Start the service and begin PnP initialization of the device again */
 586             Status = IopActionInitChildServices(DeviceNode, DeviceNode->Parent);
 587             DPRINT1("A new driver will be loaded for '%wZ' (no FDO above)\n", &DeviceNode->InstancePath);
 588         }
 589     }
 590
 591     ObDereferenceObject(DeviceObject);
 592
 593     return Status;
 594 }
 595
 596 /* PUBLIC FUNCTIONS **********************************************************/
 597
 598 /*
 599  * Plug and Play event structure used by NtGetPlugPlayEvent.
 600  *
 601  * EventGuid
 602  *    Can be one of the following values:
 603  *       GUID_HWPROFILE_QUERY_CHANGE
 604  *       GUID_HWPROFILE_CHANGE_CANCELLED
 605  *       GUID_HWPROFILE_CHANGE_COMPLETE
 606  *       GUID_TARGET_DEVICE_QUERY_REMOVE
 607  *       GUID_TARGET_DEVICE_REMOVE_CANCELLED
 608  *       GUID_TARGET_DEVICE_REMOVE_COMPLETE
 609  *       GUID_PNP_CUSTOM_NOTIFICATION
 610  *       GUID_PNP_POWER_NOTIFICATION
 611  *       GUID_DEVICE_* (see above)
 612  *
 613  * EventCategory
 614  *    Type of the event that happened.
 615  *
 616  * Result
 617  *    ?
 618  *
 619  * Flags
 620  *    ?
 621  *
 622  * TotalSize
 623  *    Size of the event block including the device IDs and other
 624  *    per category specific fields.
 625  */
 626
 627 /*
 628  * NtGetPlugPlayEvent
 629  *
 630  * Returns one Plug & Play event from a global queue.
 631  *
 632  * Parameters
 633  *    Reserved1
 634  *    Reserved2
 635  *       Always set to zero.
 636  *
 637  *    Buffer
 638  *       The buffer that will be filled with the event information on
 639  *       successful return from the function.
 640  *
 641  *    BufferSize
 642  *       Size of the buffer pointed by the Buffer parameter. If the
 643  *       buffer size is not large enough to hold the whole event
 644  *       information, error STATUS_BUFFER_TOO_SMALL is returned and
 645  *       the buffer remains untouched.
 646  *
 647  * Return Values
 648  *    STATUS_PRIVILEGE_NOT_HELD
 649  *    STATUS_BUFFER_TOO_SMALL
 650  *    STATUS_SUCCESS
 651  *
 652  * Remarks
 653  *    This function isn't multi-thread safe!
 654  *
 655  * @implemented
 656  */
 657 NTSTATUS
 658 NTAPI
 659 NtGetPlugPlayEvent(IN ULONG Reserved1,
 660                    IN ULONG Reserved2,
 661                    OUT PPLUGPLAY_EVENT_BLOCK Buffer,
 662                    IN ULONG BufferSize)
 663 {
 664     PPNP_EVENT_ENTRY Entry;
 665     NTSTATUS Status;
 666
 667     DPRINT("NtGetPlugPlayEvent() called\n");
 668
 669     /* Function can only be called from user-mode */
 670     if (KeGetPreviousMode() == KernelMode)
 671     {
 672         DPRINT1("NtGetPlugPlayEvent cannot be called from kernel mode!\n");
 673         return STATUS_ACCESS_DENIED;
 674     }
 675
 676     /* Check for Tcb privilege */
 677     if (!SeSinglePrivilegeCheck(SeTcbPrivilege,
 678                                 UserMode))
 679     {
 680         DPRINT1("NtGetPlugPlayEvent: Caller does not hold the SeTcbPrivilege privilege!\n");
 681         return STATUS_PRIVILEGE_NOT_HELD;
 682     }
 683
 684     /* Wait for a PnP event */
 685     DPRINT("Waiting for pnp notification event\n");
 686     Status = KeWaitForSingleObject(&IopPnpNotifyEvent,
 687                                    UserRequest,
 688                                    KernelMode,
 689                                    FALSE,
 690                                    NULL);
 691     if (!NT_SUCCESS(Status))
 692     {
 693         DPRINT1("KeWaitForSingleObject() failed (Status %lx)\n", Status);
 694         return Status;
 695     }
 696
 697     /* Get entry from the tail of the queue */
 698     Entry = CONTAINING_RECORD(IopPnpEventQueueHead.Blink,
 699                               PNP_EVENT_ENTRY,
 700                               ListEntry);
 701
 702     /* Check the buffer size */
 703     if (BufferSize < Entry->Event.TotalSize)
 704     {
 705         DPRINT1("Buffer is too small for the pnp-event\n");
 706         return STATUS_BUFFER_TOO_SMALL;
 707     }
 708
 709     /* Copy event data to the user buffer */
 710     memcpy(Buffer,
 711            &Entry->Event,
 712            Entry->Event.TotalSize);
 713
 714     DPRINT("NtGetPlugPlayEvent() done\n");
 715
 716     return STATUS_SUCCESS;
 717 }
 718
 719 /*
 720  * NtPlugPlayControl
 721  *
 722  * A function for doing various Plug & Play operations from user mode.
 723  *
 724  * Parameters
 725  *    PlugPlayControlClass
 726  *       0x00   Reenumerate device tree
 727  *
 728  *              Buffer points to UNICODE_STRING decribing the instance
 729  *              path (like "HTREE\ROOT\0" or "Root\ACPI_HAL\0000"). For
 730  *              more information about instance paths see !devnode command
 731  *              in kernel debugger or look at "Inside Windows 2000" book,
 732  *              chapter "Driver Loading, Initialization, and Installation".
 733  *
 734  *       0x01   Register new device
 735  *       0x02   Deregister device
 736  *       0x03   Initialize device
 737  *       0x04   Start device
 738  *       0x06   Query and remove device
 739  *       0x07   User response
 740  *
 741  *              Called after processing the message from NtGetPlugPlayEvent.
 742  *
 743  *       0x08   Generate legacy device
 744  *       0x09   Get interface device list
 745  *       0x0A   Get property data
 746  *       0x0B   Device class association (Registration)
 747  *       0x0C   Get related device
 748  *       0x0D   Get device interface alias
 749  *       0x0E   Get/set/clear device status
 750  *       0x0F   Get device depth
 751  *       0x10   Query device relations
 752  *       0x11   Query target device relation
 753  *       0x12   Query conflict list
 754  *       0x13   Retrieve dock data
 755  *       0x14   Reset device
 756  *       0x15   Halt device
 757  *       0x16   Get blocked driver data
 758  *
 759  *    Buffer
 760  *       The buffer contains information that is specific to each control
 761  *       code. The buffer is read-only.
 762  *
 763  *    BufferSize
 764  *       Size of the buffer pointed by the Buffer parameter. If the
 765  *       buffer size specifies incorrect value for specified control
 766  *       code, error ??? is returned.
 767  *
 768  * Return Values
 769  *    STATUS_PRIVILEGE_NOT_HELD
 770  *    STATUS_SUCCESS
 771  *    ...
 772  *
 773  * @unimplemented
 774  */
 775 NTSTATUS
 776 NTAPI
 777 NtPlugPlayControl(IN PLUGPLAY_CONTROL_CLASS PlugPlayControlClass,
 778                   IN OUT PVOID Buffer,
 779                   IN ULONG BufferLength)
 780 {
 781     DPRINT("NtPlugPlayControl(%lu %p %lu) called\n",
 782            PlugPlayControlClass, Buffer, BufferLength);
 783
 784     /* Function can only be called from user-mode */
 785     if (KeGetPreviousMode() == KernelMode)
 786     {
 787         DPRINT1("NtGetPlugPlayEvent cannot be called from kernel mode!\n");
 788         return STATUS_ACCESS_DENIED;
 789     }
 790
 791     /* Check for Tcb privilege */
 792     if (!SeSinglePrivilegeCheck(SeTcbPrivilege,
 793                                 UserMode))
 794     {
 795         DPRINT1("NtGetPlugPlayEvent: Caller does not hold the SeTcbPrivilege privilege!\n");
 796         return STATUS_PRIVILEGE_NOT_HELD;
 797     }
 798
 799     /* Probe the buffer */
 800     _SEH2_TRY
 801     {
 802         ProbeForWrite(Buffer,
 803                       BufferLength,
 804                       sizeof(ULONG));
 805     }
 806     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 807     {
 808         _SEH2_YIELD(return _SEH2_GetExceptionCode());
 809     }
 810     _SEH2_END;
 811
 812     switch (PlugPlayControlClass)
 813     {
 814         case PlugPlayControlUserResponse:
 815             if (Buffer || BufferLength != 0)
 816                 return STATUS_INVALID_PARAMETER;
 817             return IopRemovePlugPlayEvent();
 818
 819         case PlugPlayControlProperty:
 820             if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_PROPERTY_DATA))
 821                 return STATUS_INVALID_PARAMETER;
 822             return IopGetDeviceProperty((PPLUGPLAY_CONTROL_PROPERTY_DATA)Buffer);
 823
 824         case PlugPlayControlGetRelatedDevice:
 825             if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_RELATED_DEVICE_DATA))
 826                 return STATUS_INVALID_PARAMETER;
 827             return IopGetRelatedDevice((PPLUGPLAY_CONTROL_RELATED_DEVICE_DATA)Buffer);
 828
 829         case PlugPlayControlDeviceStatus:
 830             if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_STATUS_DATA))
 831                 return STATUS_INVALID_PARAMETER;
 832             return IopDeviceStatus((PPLUGPLAY_CONTROL_STATUS_DATA)Buffer);
 833
 834         case PlugPlayControlGetDeviceDepth:
 835             if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_DEPTH_DATA))
 836                 return STATUS_INVALID_PARAMETER;
 837             return IopGetDeviceDepth((PPLUGPLAY_CONTROL_DEPTH_DATA)Buffer);
 838
 839         case PlugPlayControlResetDevice:
 840             if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_RESET_DEVICE_DATA))
 841                 return STATUS_INVALID_PARAMETER;
 842             return IopResetDevice((PPLUGPLAY_CONTROL_RESET_DEVICE_DATA)Buffer);
 843
 844         default:
 845             return STATUS_NOT_IMPLEMENTED;
 846     }
 847
 848     return STATUS_NOT_IMPLEMENTED;
 849 }