reactos/ntoskrnl/io/pnpmgr/pnpmgr.c

   1 /*
   2  * PROJECT:         ReactOS Kernel
   3  * COPYRIGHT:       GPL - See COPYING in the top level directory
   4  * FILE:            ntoskrnl/io/pnpmgr/pnpmgr.c
   5  * PURPOSE:         Initializes the PnP manager
   6  * PROGRAMMERS:     Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  *                  Copyright 2007 Hervé Poussineau (hpoussin@reactos.org)
   8  */
   9
  10 /* INCLUDES ******************************************************************/
  11
  12 #include <ntoskrnl.h>
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16 //#define ENABLE_ACPI
  17
  18 /* GLOBALS *******************************************************************/
  19
  20 PDEVICE_NODE IopRootDeviceNode;
  21 KSPIN_LOCK IopDeviceTreeLock;
  22 ERESOURCE PpRegistryDeviceResource;
  23 KGUARDED_MUTEX PpDeviceReferenceTableLock;
  24 RTL_AVL_TABLE PpDeviceReferenceTable;
  25
  26 extern ULONG ExpInitializationPhase;
  27 extern BOOLEAN PnpSystemInit;
  28
  29 /* DATA **********************************************************************/
  30
  31 PDRIVER_OBJECT IopRootDriverObject;
  32 FAST_MUTEX IopBusTypeGuidListLock;
  33 PIO_BUS_TYPE_GUID_LIST IopBusTypeGuidList = NULL;
  34
  35 #if defined (ALLOC_PRAGMA)
  36 #pragma alloc_text(INIT, PnpInit)
  37 #pragma alloc_text(INIT, PnpInit2)
  38 #endif
  39
  40 typedef struct _INVALIDATE_DEVICE_RELATION_DATA
  41 {
  42     PDEVICE_OBJECT DeviceObject;
  43     DEVICE_RELATION_TYPE Type;
  44     PIO_WORKITEM WorkItem;
  45 } INVALIDATE_DEVICE_RELATION_DATA, *PINVALIDATE_DEVICE_RELATION_DATA;
  46
  47 /* FUNCTIONS *****************************************************************/
  48
  49 NTSTATUS
  50 IopAssignDeviceResources(
  51    IN PDEVICE_NODE DeviceNode,
  52    OUT ULONG *pRequiredSize);
  53
  54 NTSTATUS
  55 IopTranslateDeviceResources(
  56    IN PDEVICE_NODE DeviceNode,
  57    IN ULONG RequiredSize);
  58
  59 PDEVICE_NODE
  60 FASTCALL
  61 IopGetDeviceNode(PDEVICE_OBJECT DeviceObject)
  62 {
  63    return ((PEXTENDED_DEVOBJ_EXTENSION)DeviceObject->DeviceObjectExtension)->DeviceNode;
  64 }
  65
  66 NTSTATUS
  67 FASTCALL
  68 IopInitializeDevice(PDEVICE_NODE DeviceNode,
  69                     PDRIVER_OBJECT DriverObject)
  70 {
  71    PDEVICE_OBJECT Fdo;
  72    NTSTATUS Status;
  73
  74    if (!DriverObject->DriverExtension->AddDevice)
  75       return STATUS_SUCCESS;
  76
  77    /* This is a Plug and Play driver */
  78    DPRINT("Plug and Play driver found\n");
  79    ASSERT(DeviceNode->PhysicalDeviceObject);
  80
  81    /* Check if this plug-and-play driver is used as a legacy one for this device node */
  82    if (IopDeviceNodeHasFlag(DeviceNode, DNF_LEGACY_DRIVER))
  83    {
  84       IopDeviceNodeSetFlag(DeviceNode, DNF_ADDED);
  85       return STATUS_SUCCESS;
  86    }
  87
  88    DPRINT("Calling %wZ->AddDevice(%wZ)\n",
  89       &DriverObject->DriverName,
  90       &DeviceNode->InstancePath);
  91    Status = DriverObject->DriverExtension->AddDevice(
  92       DriverObject, DeviceNode->PhysicalDeviceObject);
  93    if (!NT_SUCCESS(Status))
  94    {
  95       IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
  96       return Status;
  97    }
  98
  99    /* Check if driver added a FDO above the PDO */
 100    Fdo = IoGetAttachedDeviceReference(DeviceNode->PhysicalDeviceObject);
 101    if (Fdo == DeviceNode->PhysicalDeviceObject)
 102    {
 103       /* FIXME: What do we do? Unload the driver or just disable the device? */
 104       DPRINT1("An FDO was not attached\n");
 105       ObDereferenceObject(Fdo);
 106       IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
 107       return STATUS_UNSUCCESSFUL;
 108    }
 109
 110    /* Check if we have a ACPI device (needed for power management) */
 111    if (Fdo->DeviceType == FILE_DEVICE_ACPI)
 112    {
 113       static BOOLEAN SystemPowerDeviceNodeCreated = FALSE;
 114
 115       /* There can be only one system power device */
 116       if (!SystemPowerDeviceNodeCreated)
 117       {
 118          PopSystemPowerDeviceNode = DeviceNode;
 119          ObReferenceObject(PopSystemPowerDeviceNode);
 120          SystemPowerDeviceNodeCreated = TRUE;
 121       }
 122    }
 123
 124    ObDereferenceObject(Fdo);
 125
 126    IopDeviceNodeSetFlag(DeviceNode, DNF_ADDED);
 127    IopDeviceNodeSetFlag(DeviceNode, DNF_NEED_ENUMERATION_ONLY);
 128
 129    return STATUS_SUCCESS;
 130 }
 131
 132 NTSTATUS
 133 IopStartDevice(
 134    PDEVICE_NODE DeviceNode)
 135 {
 136    IO_STATUS_BLOCK IoStatusBlock;
 137    IO_STACK_LOCATION Stack;
 138    ULONG RequiredLength;
 139    NTSTATUS Status;
 140
 141    IopDeviceNodeSetFlag(DeviceNode, DNF_ASSIGNING_RESOURCES);
 142    DPRINT("Sending IRP_MN_FILTER_RESOURCE_REQUIREMENTS to device stack\n");
 143    Stack.Parameters.FilterResourceRequirements.IoResourceRequirementList = DeviceNode->ResourceRequirements;
 144    Status = IopInitiatePnpIrp(
 145       DeviceNode->PhysicalDeviceObject,
 146       &IoStatusBlock,
 147       IRP_MN_FILTER_RESOURCE_REQUIREMENTS,
 148       &Stack);
 149    if (!NT_SUCCESS(Status) && Status != STATUS_NOT_SUPPORTED)
 150    {
 151       DPRINT("IopInitiatePnpIrp(IRP_MN_FILTER_RESOURCE_REQUIREMENTS) failed\n");
 152       return Status;
 153    }
 154    DeviceNode->ResourceRequirements = (PIO_RESOURCE_REQUIREMENTS_LIST)IoStatusBlock.Information;
 155
 156    Status = IopAssignDeviceResources(DeviceNode, &RequiredLength);
 157    if (NT_SUCCESS(Status))
 158    {
 159       Status = IopTranslateDeviceResources(DeviceNode, RequiredLength);
 160       if (NT_SUCCESS(Status))
 161       {
 162          IopDeviceNodeSetFlag(DeviceNode, DNF_RESOURCE_ASSIGNED);
 163       }
 164       else
 165       {
 166          DPRINT("IopTranslateDeviceResources() failed (Status 0x%08lx)\n", Status);
 167       }
 168    }
 169    else
 170    {
 171       DPRINT("IopAssignDeviceResources() failed (Status 0x%08lx)\n", Status);
 172    }
 173    IopDeviceNodeClearFlag(DeviceNode, DNF_ASSIGNING_RESOURCES);
 174
 175    DPRINT("Sending IRP_MN_START_DEVICE to driver\n");
 176    Stack.Parameters.StartDevice.AllocatedResources = DeviceNode->ResourceList;
 177    Stack.Parameters.StartDevice.AllocatedResourcesTranslated = DeviceNode->ResourceListTranslated;
 178
 179    /*
 180     * Windows NT Drivers receive IRP_MN_START_DEVICE in a critical region and
 181     * actually _depend_ on this!. This is because NT will lock the Device Node
 182     * with an ERESOURCE, which of course requires APCs to be disabled.
 183     */
 184    KeEnterCriticalRegion();
 185
 186    Status = IopInitiatePnpIrp(
 187       DeviceNode->PhysicalDeviceObject,
 188       &IoStatusBlock,
 189       IRP_MN_START_DEVICE,
 190       &Stack);
 191
 192    KeLeaveCriticalRegion();
 193
 194    if (!NT_SUCCESS(Status))
 195    {
 196       DPRINT("IopInitiatePnpIrp() failed\n");
 197    }
 198    else
 199    {
 200       if (IopDeviceNodeHasFlag(DeviceNode, DNF_NEED_ENUMERATION_ONLY))
 201       {
 202          DPRINT("Device needs enumeration, invalidating bus relations\n");
 203          /* Invalidate device relations synchronously
 204             (otherwise there will be dirty read of DeviceNode) */
 205          IopEnumerateDevice(DeviceNode->PhysicalDeviceObject);
 206          IopDeviceNodeClearFlag(DeviceNode, DNF_NEED_ENUMERATION_ONLY);
 207       }
 208    }
 209
 210    if (NT_SUCCESS(Status))
 211        IopDeviceNodeSetFlag(DeviceNode, DNF_STARTED);
 212
 213    return Status;
 214 }
 215
 216 NTSTATUS
 217 NTAPI
 218 IopQueryDeviceCapabilities(PDEVICE_NODE DeviceNode,
 219                            PDEVICE_CAPABILITIES DeviceCaps)
 220 {
 221    IO_STATUS_BLOCK StatusBlock;
 222    IO_STACK_LOCATION Stack;
 223
 224    /* Set up the Header */
 225    RtlZeroMemory(DeviceCaps, sizeof(DEVICE_CAPABILITIES));
 226    DeviceCaps->Size = sizeof(DEVICE_CAPABILITIES);
 227    DeviceCaps->Version = 1;
 228    DeviceCaps->Address = -1;
 229    DeviceCaps->UINumber = -1;
 230
 231    /* Set up the Stack */
 232    RtlZeroMemory(&Stack, sizeof(IO_STACK_LOCATION));
 233    Stack.Parameters.DeviceCapabilities.Capabilities = DeviceCaps;
 234
 235    /* Send the IRP */
 236    return IopInitiatePnpIrp(DeviceNode->PhysicalDeviceObject,
 237                             &StatusBlock,
 238                             IRP_MN_QUERY_CAPABILITIES,
 239                             &Stack);
 240 }
 241
 242 static VOID NTAPI
 243 IopAsynchronousInvalidateDeviceRelations(
 244     IN PDEVICE_OBJECT DeviceObject,
 245     IN PVOID InvalidateContext)
 246 {
 247     PINVALIDATE_DEVICE_RELATION_DATA Data = InvalidateContext;
 248
 249     IoSynchronousInvalidateDeviceRelations(
 250         Data->DeviceObject,
 251         Data->Type);
 252
 253     ObDereferenceObject(Data->DeviceObject);
 254     IoFreeWorkItem(Data->WorkItem);
 255     ExFreePool(Data);
 256 }
 257
 258 NTSTATUS
 259 IopGetSystemPowerDeviceObject(PDEVICE_OBJECT *DeviceObject)
 260 {
 261    KIRQL OldIrql;
 262
 263    if (PopSystemPowerDeviceNode)
 264    {
 265       KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
 266       *DeviceObject = PopSystemPowerDeviceNode->PhysicalDeviceObject;
 267       KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
 268
 269       return STATUS_SUCCESS;
 270    }
 271
 272    return STATUS_UNSUCCESSFUL;
 273 }
 274
 275 USHORT
 276 NTAPI
 277 IopGetBusTypeGuidIndex(LPGUID BusTypeGuid)
 278 {
 279    USHORT i = 0, FoundIndex = 0xFFFF;
 280    ULONG NewSize;
 281    PVOID NewList;
 282
 283    /* Acquire the lock */
 284    ExAcquireFastMutex(&IopBusTypeGuidListLock);
 285
 286    /* Loop all entries */
 287    while (i < IopBusTypeGuidList->GuidCount)
 288    {
 289        /* Try to find a match */
 290        if (RtlCompareMemory(BusTypeGuid,
 291                             &IopBusTypeGuidList->Guids[i],
 292                             sizeof(GUID)) == sizeof(GUID))
 293        {
 294            /* Found it */
 295            FoundIndex = i;
 296            goto Quickie;
 297        }
 298        i++;
 299    }
 300
 301    /* Check if we have to grow the list */
 302    if (IopBusTypeGuidList->GuidCount)
 303    {
 304        /* Calculate the new size */
 305        NewSize = sizeof(IO_BUS_TYPE_GUID_LIST) +
 306                 (sizeof(GUID) * IopBusTypeGuidList->GuidCount);
 307
 308        /* Allocate the new copy */
 309        NewList = ExAllocatePool(PagedPool, NewSize);
 310
 311        if (!NewList) {
 312            /* Fail */
 313            ExFreePool(IopBusTypeGuidList);
 314            goto Quickie;
 315        }
 316
 317        /* Now copy them, decrease the size too */
 318        NewSize -= sizeof(GUID);
 319        RtlCopyMemory(NewList, IopBusTypeGuidList, NewSize);
 320
 321        /* Free the old list */
 322        ExFreePool(IopBusTypeGuidList);
 323
 324        /* Use the new buffer */
 325        IopBusTypeGuidList = NewList;
 326    }
 327
 328    /* Copy the new GUID */
 329    RtlCopyMemory(&IopBusTypeGuidList->Guids[IopBusTypeGuidList->GuidCount],
 330                  BusTypeGuid,
 331                  sizeof(GUID));
 332
 333    /* The new entry is the index */
 334    FoundIndex = (USHORT)IopBusTypeGuidList->GuidCount;
 335    IopBusTypeGuidList->GuidCount++;
 336
 337 Quickie:
 338    ExReleaseFastMutex(&IopBusTypeGuidListLock);
 339    return FoundIndex;
 340 }
 341
 342 /*
 343  * DESCRIPTION
 344  *      Creates a device node
 345  *
 346  * ARGUMENTS
 347  *   ParentNode           = Pointer to parent device node
 348  *   PhysicalDeviceObject = Pointer to PDO for device object. Pass NULL
 349  *                          to have the root device node create one
 350  *                          (eg. for legacy drivers)
 351  *   DeviceNode           = Pointer to storage for created device node
 352  *
 353  * RETURN VALUE
 354  *      Status
 355  */
 356 NTSTATUS
 357 IopCreateDeviceNode(PDEVICE_NODE ParentNode,
 358                     PDEVICE_OBJECT PhysicalDeviceObject,
 359                     PUNICODE_STRING ServiceName,
 360                     PDEVICE_NODE *DeviceNode)
 361 {
 362    PDEVICE_NODE Node;
 363    NTSTATUS Status;
 364    KIRQL OldIrql;
 365    UNICODE_STRING FullServiceName;
 366    UNICODE_STRING LegacyPrefix = RTL_CONSTANT_STRING(L"LEGACY_");
 367
 368    DPRINT("ParentNode 0x%p PhysicalDeviceObject 0x%p ServiceName %wZ\n",
 369       ParentNode, PhysicalDeviceObject, ServiceName);
 370
 371    Node = (PDEVICE_NODE)ExAllocatePool(NonPagedPool, sizeof(DEVICE_NODE));
 372    if (!Node)
 373    {
 374       return STATUS_INSUFFICIENT_RESOURCES;
 375    }
 376
 377    RtlZeroMemory(Node, sizeof(DEVICE_NODE));
 378
 379    if (!PhysicalDeviceObject)
 380    {
 381       if (ServiceName)
 382       {
 383          FullServiceName.MaximumLength = LegacyPrefix.Length + ServiceName->Length;
 384          FullServiceName.Length = 0;
 385          FullServiceName.Buffer = ExAllocatePool(PagedPool, FullServiceName.MaximumLength);
 386          if (!FullServiceName.Buffer)
 387          {
 388             ExFreePool(Node);
 389             return STATUS_INSUFFICIENT_RESOURCES;
 390          }
 391
 392          RtlAppendUnicodeStringToString(&FullServiceName, &LegacyPrefix);
 393          RtlAppendUnicodeStringToString(&FullServiceName, ServiceName);
 394       }
 395
 396       Status = PnpRootCreateDevice(ServiceName ? &FullServiceName : NULL, &PhysicalDeviceObject);
 397       if (!NT_SUCCESS(Status))
 398       {
 399          DPRINT1("PnpRootCreateDevice() failed with status 0x%08X\n", Status);
 400          ExFreePool(Node);
 401          return Status;
 402       }
 403
 404       /* This is for drivers passed on the command line to ntoskrnl.exe */
 405       IopDeviceNodeSetFlag(Node, DNF_STARTED);
 406       IopDeviceNodeSetFlag(Node, DNF_LEGACY_DRIVER);
 407    }
 408
 409    Node->PhysicalDeviceObject = PhysicalDeviceObject;
 410
 411    ((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode = Node;
 412
 413     if (ParentNode)
 414     {
 415         KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
 416         Node->Parent = ParentNode;
 417         Node->Sibling = ParentNode->Child;
 418         ParentNode->Child = Node;
 419         if (ParentNode->LastChild == NULL)
 420             ParentNode->LastChild = Node;
 421         KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
 422         Node->Level = ParentNode->Level + 1;
 423     }
 424
 425     PhysicalDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 426
 427    *DeviceNode = Node;
 428
 429    return STATUS_SUCCESS;
 430 }
 431
 432 NTSTATUS
 433 IopFreeDeviceNode(PDEVICE_NODE DeviceNode)
 434 {
 435    KIRQL OldIrql;
 436    PDEVICE_NODE PrevSibling = NULL;
 437
 438    /* All children must be deleted before a parent is deleted */
 439    ASSERT(!DeviceNode->Child);
 440
 441    KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
 442
 443    ASSERT(DeviceNode->PhysicalDeviceObject);
 444
 445    ObDereferenceObject(DeviceNode->PhysicalDeviceObject);
 446
 447     /* Get previous sibling */
 448     if (DeviceNode->Parent && DeviceNode->Parent->Child != DeviceNode)
 449     {
 450         PrevSibling = DeviceNode->Parent->Child;
 451         while (PrevSibling->Sibling != DeviceNode)
 452             PrevSibling = PrevSibling->Sibling;
 453     }
 454
 455     /* Unlink from parent if it exists */
 456     if (DeviceNode->Parent)
 457     {
 458         if (DeviceNode->Parent->LastChild == DeviceNode)
 459         {
 460             DeviceNode->Parent->LastChild = PrevSibling;
 461             if (PrevSibling)
 462                 PrevSibling->Sibling = NULL;
 463         }
 464         if (DeviceNode->Parent->Child == DeviceNode)
 465             DeviceNode->Parent->Child = DeviceNode->Sibling;
 466     }
 467
 468     /* Unlink from sibling list */
 469     if (PrevSibling)
 470         PrevSibling->Sibling = DeviceNode->Sibling;
 471
 472    KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
 473
 474    RtlFreeUnicodeString(&DeviceNode->InstancePath);
 475
 476    RtlFreeUnicodeString(&DeviceNode->ServiceName);
 477
 478    if (DeviceNode->ResourceList)
 479    {
 480       ExFreePool(DeviceNode->ResourceList);
 481    }
 482
 483    if (DeviceNode->ResourceListTranslated)
 484    {
 485       ExFreePool(DeviceNode->ResourceListTranslated);
 486    }
 487
 488    if (DeviceNode->ResourceRequirements)
 489    {
 490       ExFreePool(DeviceNode->ResourceRequirements);
 491    }
 492
 493    if (DeviceNode->BootResources)
 494    {
 495       ExFreePool(DeviceNode->BootResources);
 496    }
 497
 498    ExFreePool(DeviceNode);
 499
 500    return STATUS_SUCCESS;
 501 }
 502
 503 NTSTATUS
 504 IopInitiatePnpIrp(PDEVICE_OBJECT DeviceObject,
 505                   PIO_STATUS_BLOCK IoStatusBlock,
 506                   ULONG MinorFunction,
 507                   PIO_STACK_LOCATION Stack OPTIONAL)
 508 {
 509    PDEVICE_OBJECT TopDeviceObject;
 510    PIO_STACK_LOCATION IrpSp;
 511    NTSTATUS Status;
 512    KEVENT Event;
 513    PIRP Irp;
 514
 515    /* Always call the top of the device stack */
 516    TopDeviceObject = IoGetAttachedDeviceReference(DeviceObject);
 517
 518    KeInitializeEvent(
 519       &Event,
 520       NotificationEvent,
 521       FALSE);
 522
 523    Irp = IoBuildSynchronousFsdRequest(
 524       IRP_MJ_PNP,
 525       TopDeviceObject,
 526       NULL,
 527       0,
 528       NULL,
 529       &Event,
 530       IoStatusBlock);
 531
 532    /* PNP IRPs are initialized with a status code of STATUS_NOT_SUPPORTED */
 533    Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 534    Irp->IoStatus.Information = 0;
 535
 536    if (MinorFunction == IRP_MN_FILTER_RESOURCE_REQUIREMENTS)
 537    {
 538       Irp->IoStatus.Information = (ULONG_PTR)Stack->Parameters.FilterResourceRequirements.IoResourceRequirementList;
 539    }
 540
 541    IrpSp = IoGetNextIrpStackLocation(Irp);
 542    IrpSp->MinorFunction = (UCHAR)MinorFunction;
 543
 544    if (Stack)
 545    {
 546       RtlCopyMemory(&IrpSp->Parameters,
 547                     &Stack->Parameters,
 548                     sizeof(Stack->Parameters));
 549    }
 550
 551    Status = IoCallDriver(TopDeviceObject, Irp);
 552    if (Status == STATUS_PENDING)
 553    {
 554       KeWaitForSingleObject(&Event,
 555                             Executive,
 556                             KernelMode,
 557                             FALSE,
 558                             NULL);
 559       Status = IoStatusBlock->Status;
 560    }
 561
 562    ObDereferenceObject(TopDeviceObject);
 563
 564    return Status;
 565 }
 566
 567
 568 NTSTATUS
 569 IopTraverseDeviceTreeNode(PDEVICETREE_TRAVERSE_CONTEXT Context)
 570 {
 571    PDEVICE_NODE ParentDeviceNode;
 572    PDEVICE_NODE ChildDeviceNode;
 573    NTSTATUS Status;
 574
 575    /* Copy context data so we don't overwrite it in subsequent calls to this function */
 576    ParentDeviceNode = Context->DeviceNode;
 577
 578    /* Call the action routine */
 579    Status = (Context->Action)(ParentDeviceNode, Context->Context);
 580    if (!NT_SUCCESS(Status))
 581    {
 582       return Status;
 583    }
 584
 585    /* Traversal of all children nodes */
 586    for (ChildDeviceNode = ParentDeviceNode->Child;
 587         ChildDeviceNode != NULL;
 588         ChildDeviceNode = ChildDeviceNode->Sibling)
 589    {
 590       /* Pass the current device node to the action routine */
 591       Context->DeviceNode = ChildDeviceNode;
 592
 593       Status = IopTraverseDeviceTreeNode(Context);
 594       if (!NT_SUCCESS(Status))
 595       {
 596          return Status;
 597       }
 598    }
 599
 600    return Status;
 601 }
 602
 603
 604 NTSTATUS
 605 IopTraverseDeviceTree(PDEVICETREE_TRAVERSE_CONTEXT Context)
 606 {
 607    NTSTATUS Status;
 608
 609    DPRINT("Context 0x%p\n", Context);
 610
 611    DPRINT("IopTraverseDeviceTree(DeviceNode 0x%p  FirstDeviceNode 0x%p  Action %x  Context 0x%p)\n",
 612       Context->DeviceNode, Context->FirstDeviceNode, Context->Action, Context->Context);
 613
 614    /* Start from the specified device node */
 615    Context->DeviceNode = Context->FirstDeviceNode;
 616
 617    /* Recursively traverse the device tree */
 618    Status = IopTraverseDeviceTreeNode(Context);
 619    if (Status == STATUS_UNSUCCESSFUL)
 620    {
 621       /* The action routine just wanted to terminate the traversal with status
 622       code STATUS_SUCCESS */
 623       Status = STATUS_SUCCESS;
 624    }
 625
 626    return Status;
 627 }
 628
 629
 630 /*
 631  * IopCreateDeviceKeyPath
 632  *
 633  * Creates a registry key
 634  *
 635  * Parameters
 636  *    RegistryPath
 637  *        Name of the key to be created.
 638  *    Handle
 639  *        Handle to the newly created key
 640  *
 641  * Remarks
 642  *     This method can create nested trees, so parent of RegistryPath can
 643  *     be not existant, and will be created if needed.
 644  */
 645 NTSTATUS
 646 NTAPI
 647 IopCreateDeviceKeyPath(IN PCUNICODE_STRING RegistryPath,
 648                        OUT PHANDLE Handle)
 649 {
 650     UNICODE_STRING EnumU = RTL_CONSTANT_STRING(ENUM_ROOT);
 651     HANDLE hParent = NULL, hKey;
 652     OBJECT_ATTRIBUTES ObjectAttributes;
 653     UNICODE_STRING KeyName;
 654     LPCWSTR Current, Last;
 655     ULONG dwLength;
 656     NTSTATUS Status;
 657
 658     /* Assume failure */
 659     *Handle = NULL;
 660
 661     /* Open root key for device instances */
 662     Status = IopOpenRegistryKeyEx(&hParent, NULL, &EnumU, KEY_CREATE_SUB_KEY);
 663     if (!NT_SUCCESS(Status))
 664     {
 665         DPRINT1("ZwOpenKey('%wZ') failed with status 0x%08lx\n", &EnumU, Status);
 666         return Status;
 667     }
 668
 669     Current = KeyName.Buffer = RegistryPath->Buffer;
 670     Last = &RegistryPath->Buffer[RegistryPath->Length / sizeof(WCHAR)];
 671
 672     /* Go up to the end of the string */
 673     while (Current <= Last)
 674     {
 675         if (Current != Last && *Current != '\\')
 676         {
 677             /* Not the end of the string and not a separator */
 678             Current++;
 679             continue;
 680         }
 681
 682         /* Prepare relative key name */
 683         dwLength = (ULONG_PTR)Current - (ULONG_PTR)KeyName.Buffer;
 684         KeyName.MaximumLength = KeyName.Length = dwLength;
 685         DPRINT("Create '%wZ'\n", &KeyName);
 686
 687         /* Open key */
 688         InitializeObjectAttributes(&ObjectAttributes,
 689                                    &KeyName,
 690                                    OBJ_CASE_INSENSITIVE,
 691                                    hParent,
 692                                    NULL);
 693         Status = ZwCreateKey(&hKey,
 694                              Current == Last ? KEY_ALL_ACCESS : KEY_CREATE_SUB_KEY,
 695                              &ObjectAttributes,
 696                              0,
 697                              NULL,
 698                              0,
 699                              NULL);
 700
 701         /* Close parent key handle, we don't need it anymore */
 702         if (hParent)
 703             ZwClose(hParent);
 704
 705         /* Key opening/creating failed? */
 706         if (!NT_SUCCESS(Status))
 707         {
 708             DPRINT1("ZwCreateKey('%wZ') failed with status 0x%08lx\n", &KeyName, Status);
 709             return Status;
 710         }
 711
 712         /* Check if it is the end of the string */
 713         if (Current == Last)
 714         {
 715             /* Yes, return success */
 716             *Handle = hKey;
 717             return STATUS_SUCCESS;
 718         }
 719
 720         /* Start with this new parent key */
 721         hParent = hKey;
 722         Current++;
 723         KeyName.Buffer = (LPWSTR)Current;
 724     }
 725
 726     return STATUS_UNSUCCESSFUL;
 727 }
 728
 729
 730 NTSTATUS
 731 IopSetDeviceInstanceData(HANDLE InstanceKey,
 732                          PDEVICE_NODE DeviceNode)
 733 {
 734    OBJECT_ATTRIBUTES ObjectAttributes;
 735    UNICODE_STRING KeyName;
 736    HANDLE LogConfKey;
 737    ULONG ResCount;
 738    ULONG ListSize, ResultLength;
 739    NTSTATUS Status;
 740
 741    DPRINT("IopSetDeviceInstanceData() called\n");
 742
 743    /* Create the 'LogConf' key */
 744    RtlInitUnicodeString(&KeyName, L"LogConf");
 745    InitializeObjectAttributes(&ObjectAttributes,
 746                               &KeyName,
 747                               OBJ_CASE_INSENSITIVE,
 748                               InstanceKey,
 749                               NULL);
 750    Status = ZwCreateKey(&LogConfKey,
 751                         KEY_ALL_ACCESS,
 752                         &ObjectAttributes,
 753                         0,
 754                         NULL,
 755                         0,
 756                         NULL);
 757    if (NT_SUCCESS(Status))
 758    {
 759       /* Set 'BootConfig' value */
 760       if (DeviceNode->BootResources != NULL)
 761       {
 762          ResCount = DeviceNode->BootResources->Count;
 763          if (ResCount != 0)
 764          {
 765             ListSize = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
 766
 767             RtlInitUnicodeString(&KeyName, L"BootConfig");
 768             Status = ZwSetValueKey(LogConfKey,
 769                                    &KeyName,
 770                                    0,
 771                                    REG_RESOURCE_LIST,
 772                                    DeviceNode->BootResources,
 773                                    ListSize);
 774          }
 775       }
 776
 777       /* Set 'BasicConfigVector' value */
 778       if (DeviceNode->ResourceRequirements != NULL &&
 779          DeviceNode->ResourceRequirements->ListSize != 0)
 780       {
 781          RtlInitUnicodeString(&KeyName, L"BasicConfigVector");
 782          Status = ZwSetValueKey(LogConfKey,
 783                                 &KeyName,
 784                                 0,
 785                                 REG_RESOURCE_REQUIREMENTS_LIST,
 786                                 DeviceNode->ResourceRequirements,
 787                                 DeviceNode->ResourceRequirements->ListSize);
 788       }
 789
 790       ZwClose(LogConfKey);
 791    }
 792
 793    /* Set the 'ConfigFlags' value */
 794    RtlInitUnicodeString(&KeyName, L"ConfigFlags");
 795    Status = ZwQueryValueKey(InstanceKey,
 796                             &KeyName,
 797                             KeyValueBasicInformation,
 798                             NULL,
 799                             0,
 800                             &ResultLength);
 801   if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
 802   {
 803     /* Write the default value */
 804     ULONG DefaultConfigFlags = 0;
 805     Status = ZwSetValueKey(InstanceKey,
 806                            &KeyName,
 807                            0,
 808                            REG_DWORD,
 809                            &DefaultConfigFlags,
 810                            sizeof(DefaultConfigFlags));
 811   }
 812
 813   DPRINT("IopSetDeviceInstanceData() done\n");
 814
 815   return STATUS_SUCCESS;
 816 }
 817
 818
 819 NTSTATUS
 820 IopAssignDeviceResources(
 821    IN PDEVICE_NODE DeviceNode,
 822    OUT ULONG *pRequiredSize)
 823 {
 824    PIO_RESOURCE_LIST ResourceList;
 825    PIO_RESOURCE_DESCRIPTOR ResourceDescriptor;
 826    PCM_PARTIAL_RESOURCE_DESCRIPTOR DescriptorRaw;
 827    PCM_PARTIAL_RESOURCE_LIST pPartialResourceList;
 828    ULONG NumberOfResources = 0;
 829    ULONG Size;
 830    ULONG i, j;
 831    NTSTATUS Status;
 832
 833    if (!DeviceNode->BootResources && !DeviceNode->ResourceRequirements)
 834    {
 835       /* No resource needed for this device */
 836       DeviceNode->ResourceList = NULL;
 837       *pRequiredSize = 0;
 838       return STATUS_SUCCESS;
 839    }
 840
 841    /* Fill DeviceNode->ResourceList
 842     * FIXME: the PnP arbiter should go there!
 843     * Actually, use the BootResources if provided, else the resource list #0
 844     */
 845
 846    if (DeviceNode->BootResources)
 847    {
 848       /* Browse the boot resources to know if we have some custom structures */
 849       Size = FIELD_OFFSET(CM_RESOURCE_LIST, List);
 850       for (i = 0; i < DeviceNode->BootResources->Count; i++)
 851       {
 852          pPartialResourceList = &DeviceNode->BootResources->List[i].PartialResourceList;
 853          Size += FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR, PartialResourceList.PartialDescriptors)
 854             + pPartialResourceList->Count * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
 855          for (j = 0; j < pPartialResourceList->Count; j++)
 856          {
 857             if (pPartialResourceList->PartialDescriptors[j].Type == CmResourceTypeDeviceSpecific)
 858                Size += pPartialResourceList->PartialDescriptors[j].u.DeviceSpecificData.DataSize;
 859          }
 860       }
 861
 862       DeviceNode->ResourceList = ExAllocatePool(PagedPool, Size);
 863       if (!DeviceNode->ResourceList)
 864       {
 865          Status = STATUS_NO_MEMORY;
 866          goto ByeBye;
 867       }
 868       RtlCopyMemory(DeviceNode->ResourceList, DeviceNode->BootResources, Size);
 869
 870       *pRequiredSize = Size;
 871       return STATUS_SUCCESS;
 872    }
 873
 874    /* Ok, here, we have to use the device requirement list */
 875    ResourceList = &DeviceNode->ResourceRequirements->List[0];
 876    if (ResourceList->Version != 1 || ResourceList->Revision != 1)
 877    {
 878       Status = STATUS_REVISION_MISMATCH;
 879       goto ByeBye;
 880    }
 881
 882    Size = sizeof(CM_RESOURCE_LIST) + ResourceList->Count * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
 883    DeviceNode->ResourceList = ExAllocatePool(PagedPool, Size);
 884    if (!DeviceNode->ResourceList)
 885    {
 886       Status = STATUS_NO_MEMORY;
 887       goto ByeBye;
 888    }
 889
 890    DeviceNode->ResourceList->Count = 1;
 891    DeviceNode->ResourceList->List[0].InterfaceType = DeviceNode->ResourceRequirements->InterfaceType;
 892    DeviceNode->ResourceList->List[0].BusNumber = DeviceNode->ResourceRequirements->BusNumber;
 893    DeviceNode->ResourceList->List[0].PartialResourceList.Version = 1;
 894    DeviceNode->ResourceList->List[0].PartialResourceList.Revision = 1;
 895
 896    for (i = 0; i < ResourceList->Count; i++)
 897    {
 898       ResourceDescriptor = &ResourceList->Descriptors[i];
 899
 900       if (ResourceDescriptor->Option == 0 || ResourceDescriptor->Option == IO_RESOURCE_PREFERRED)
 901       {
 902          DescriptorRaw = &DeviceNode->ResourceList->List[0].PartialResourceList.PartialDescriptors[NumberOfResources];
 903          NumberOfResources++;
 904
 905          /* Copy ResourceDescriptor to DescriptorRaw and DescriptorTranslated */
 906          DescriptorRaw->Type = ResourceDescriptor->Type;
 907          DescriptorRaw->ShareDisposition = ResourceDescriptor->ShareDisposition;
 908          DescriptorRaw->Flags = ResourceDescriptor->Flags;
 909          switch (ResourceDescriptor->Type)
 910          {
 911             case CmResourceTypePort:
 912             {
 913                DescriptorRaw->u.Port.Start = ResourceDescriptor->u.Port.MinimumAddress;
 914                DescriptorRaw->u.Port.Length = ResourceDescriptor->u.Port.Length;
 915                break;
 916             }
 917             case CmResourceTypeInterrupt:
 918             {
 919                INTERFACE_TYPE BusType;
 920                ULONG SlotNumber;
 921                ULONG ret;
 922                UCHAR Irq;
 923
 924                DescriptorRaw->u.Interrupt.Level = 0;
 925                DescriptorRaw->u.Interrupt.Vector = ResourceDescriptor->u.Interrupt.MinimumVector;
 926                /* FIXME: HACK: if we have a PCI device, we try
 927                 * to keep the IRQ assigned by the BIOS */
 928                if (NT_SUCCESS(IoGetDeviceProperty(
 929                   DeviceNode->PhysicalDeviceObject,
 930                   DevicePropertyLegacyBusType,
 931                   sizeof(INTERFACE_TYPE),
 932                   &BusType,
 933                   &ret)) && BusType == PCIBus)
 934                {
 935                   /* We have a PCI bus */
 936                   if (NT_SUCCESS(IoGetDeviceProperty(
 937                      DeviceNode->PhysicalDeviceObject,
 938                      DevicePropertyAddress,
 939                      sizeof(ULONG),
 940                      &SlotNumber,
 941                      &ret)) && SlotNumber > 0)
 942                   {
 943                      /* We have a good slot number */
 944                      ret = HalGetBusDataByOffset(PCIConfiguration,
 945                                                  DeviceNode->ResourceRequirements->BusNumber,
 946                                                  SlotNumber,
 947                                                  &Irq,
 948                                                  0x3c /* PCI_INTERRUPT_LINE */,
 949                                                  sizeof(UCHAR));
 950                      if (ret != 0 && ret != 2
 951                          && ResourceDescriptor->u.Interrupt.MinimumVector <= Irq
 952                          && ResourceDescriptor->u.Interrupt.MaximumVector >= Irq)
 953                      {
 954                         /* The device already has an assigned IRQ */
 955                         DescriptorRaw->u.Interrupt.Vector = Irq;
 956                      }
 957                      else
 958                      {
 959                          DPRINT1("Trying to assign IRQ 0x%lx to %wZ\n",
 960                             DescriptorRaw->u.Interrupt.Vector,
 961                             &DeviceNode->InstancePath);
 962                          Irq = (UCHAR)DescriptorRaw->u.Interrupt.Vector;
 963                          ret = HalSetBusDataByOffset(PCIConfiguration,
 964                             DeviceNode->ResourceRequirements->BusNumber,
 965                             SlotNumber,
 966                             &Irq,
 967                             0x3c /* PCI_INTERRUPT_LINE */,
 968                             sizeof(UCHAR));
 969                          if (ret == 0 || ret == 2)
 970                             ASSERT(FALSE);
 971                      }
 972                   }
 973                }
 974                break;
 975             }
 976             case CmResourceTypeMemory:
 977             {
 978                DescriptorRaw->u.Memory.Start = ResourceDescriptor->u.Memory.MinimumAddress;
 979                DescriptorRaw->u.Memory.Length = ResourceDescriptor->u.Memory.Length;
 980                break;
 981             }
 982             case CmResourceTypeDma:
 983             {
 984                DescriptorRaw->u.Dma.Channel = ResourceDescriptor->u.Dma.MinimumChannel;
 985                DescriptorRaw->u.Dma.Port = 0; /* FIXME */
 986                DescriptorRaw->u.Dma.Reserved1 = 0;
 987                break;
 988             }
 989             case CmResourceTypeBusNumber:
 990             {
 991                DescriptorRaw->u.BusNumber.Start = ResourceDescriptor->u.BusNumber.MinBusNumber;
 992                DescriptorRaw->u.BusNumber.Length = ResourceDescriptor->u.BusNumber.Length;
 993                DescriptorRaw->u.BusNumber.Reserved = ResourceDescriptor->u.BusNumber.Reserved;
 994                break;
 995             }
 996             /*CmResourceTypeDevicePrivate:
 997             case CmResourceTypePcCardConfig:
 998             case CmResourceTypeMfCardConfig:
 999             {
1000                RtlCopyMemory(
1001                   &DescriptorRaw->u.DevicePrivate,
1002                   &ResourceDescriptor->u.DevicePrivate,
1003                   sizeof(ResourceDescriptor->u.DevicePrivate));
1004                RtlCopyMemory(
1005                   &DescriptorTranslated->u.DevicePrivate,
1006                   &ResourceDescriptor->u.DevicePrivate,
1007                   sizeof(ResourceDescriptor->u.DevicePrivate));
1008                break;
1009             }*/
1010             default:
1011                DPRINT1("IopAssignDeviceResources(): unknown resource descriptor type 0x%x\n", ResourceDescriptor->Type);
1012                NumberOfResources--;
1013          }
1014       }
1015
1016    }
1017
1018    DeviceNode->ResourceList->List[0].PartialResourceList.Count = NumberOfResources;
1019
1020    *pRequiredSize = Size;
1021    return STATUS_SUCCESS;
1022
1023 ByeBye:
1024    if (DeviceNode->ResourceList)
1025    {
1026       ExFreePool(DeviceNode->ResourceList);
1027       DeviceNode->ResourceList = NULL;
1028    }
1029    *pRequiredSize = 0;
1030    return Status;
1031 }
1032
1033
1034 NTSTATUS
1035 IopTranslateDeviceResources(
1036    IN PDEVICE_NODE DeviceNode,
1037    IN ULONG RequiredSize)
1038 {
1039    PCM_PARTIAL_RESOURCE_LIST pPartialResourceList;
1040    PCM_PARTIAL_RESOURCE_DESCRIPTOR DescriptorRaw, DescriptorTranslated;
1041    ULONG i, j;
1042    NTSTATUS Status;
1043
1044    if (!DeviceNode->ResourceList)
1045    {
1046       DeviceNode->ResourceListTranslated = NULL;
1047       return STATUS_SUCCESS;
1048    }
1049
1050    /* That's easy to translate a resource list. Just copy the
1051     * untranslated one and change few fields in the copy
1052     */
1053    DeviceNode->ResourceListTranslated = ExAllocatePool(PagedPool, RequiredSize);
1054    if (!DeviceNode->ResourceListTranslated)
1055    {
1056       Status =STATUS_NO_MEMORY;
1057       goto cleanup;
1058    }
1059    RtlCopyMemory(DeviceNode->ResourceListTranslated, DeviceNode->ResourceList, RequiredSize);
1060
1061    for (i = 0; i < DeviceNode->ResourceList->Count; i++)
1062    {
1063       pPartialResourceList = &DeviceNode->ResourceList->List[i].PartialResourceList;
1064       for (j = 0; j < pPartialResourceList->Count; j++)
1065       {
1066          DescriptorRaw = &pPartialResourceList->PartialDescriptors[j];
1067          DescriptorTranslated = &DeviceNode->ResourceListTranslated->List[i].PartialResourceList.PartialDescriptors[j];
1068          switch (DescriptorRaw->Type)
1069          {
1070             case CmResourceTypePort:
1071             {
1072                ULONG AddressSpace = 1; /* IO space */
1073                if (!HalTranslateBusAddress(
1074                   DeviceNode->ResourceList->List[i].InterfaceType,
1075                   DeviceNode->ResourceList->List[i].BusNumber,
1076                   DescriptorRaw->u.Port.Start,
1077                   &AddressSpace,
1078                   &DescriptorTranslated->u.Port.Start))
1079                {
1080                   Status = STATUS_UNSUCCESSFUL;
1081                   goto cleanup;
1082                }
1083                break;
1084             }
1085             case CmResourceTypeInterrupt:
1086             {
1087                DescriptorTranslated->u.Interrupt.Vector = HalGetInterruptVector(
1088                   DeviceNode->ResourceList->List[i].InterfaceType,
1089                   DeviceNode->ResourceList->List[i].BusNumber,
1090                   DescriptorRaw->u.Interrupt.Level,
1091                   DescriptorRaw->u.Interrupt.Vector,
1092                   (PKIRQL)&DescriptorTranslated->u.Interrupt.Level,
1093                   &DescriptorRaw->u.Interrupt.Affinity);
1094                break;
1095             }
1096             case CmResourceTypeMemory:
1097             {
1098                ULONG AddressSpace = 0; /* Memory space */
1099                if (!HalTranslateBusAddress(
1100                   DeviceNode->ResourceList->List[i].InterfaceType,
1101                   DeviceNode->ResourceList->List[i].BusNumber,
1102                   DescriptorRaw->u.Memory.Start,
1103                   &AddressSpace,
1104                   &DescriptorTranslated->u.Memory.Start))
1105                {
1106                   Status = STATUS_UNSUCCESSFUL;
1107                   goto cleanup;
1108                }
1109             }
1110
1111             case CmResourceTypeDma:
1112             case CmResourceTypeBusNumber:
1113             case CmResourceTypeDeviceSpecific:
1114                /* Nothing to do */
1115                break;
1116             default:
1117                DPRINT1("Unknown resource descriptor type 0x%x\n", DescriptorRaw->Type);
1118                Status = STATUS_NOT_IMPLEMENTED;
1119                goto cleanup;
1120          }
1121       }
1122    }
1123    return STATUS_SUCCESS;
1124
1125 cleanup:
1126    /* Yes! Also delete ResourceList because ResourceList and
1127     * ResourceListTranslated should be a pair! */
1128    ExFreePool(DeviceNode->ResourceList);
1129    DeviceNode->ResourceList = NULL;
1130    if (DeviceNode->ResourceListTranslated)
1131    {
1132       ExFreePool(DeviceNode->ResourceListTranslated);
1133       DeviceNode->ResourceList = NULL;
1134    }
1135    return Status;
1136 }
1137
1138
1139 /*
1140  * IopGetParentIdPrefix
1141  *
1142  * Retrieve (or create) a string which identifies a device.
1143  *
1144  * Parameters
1145  *    DeviceNode
1146  *        Pointer to device node.
1147  *    ParentIdPrefix
1148  *        Pointer to the string where is returned the parent node identifier
1149  *
1150  * Remarks
1151  *     If the return code is STATUS_SUCCESS, the ParentIdPrefix string is
1152  *     valid and its Buffer field is NULL-terminated. The caller needs to
1153  *     to free the string with RtlFreeUnicodeString when it is no longer
1154  *     needed.
1155  */
1156
1157 NTSTATUS
1158 IopGetParentIdPrefix(PDEVICE_NODE DeviceNode,
1159                      PUNICODE_STRING ParentIdPrefix)
1160 {
1161    ULONG KeyNameBufferLength;
1162    PKEY_VALUE_PARTIAL_INFORMATION ParentIdPrefixInformation = NULL;
1163    UNICODE_STRING KeyName;
1164    UNICODE_STRING KeyValue;
1165    UNICODE_STRING ValueName;
1166    HANDLE hKey = NULL;
1167    ULONG crc32;
1168    NTSTATUS Status;
1169
1170    /* HACK: As long as some devices have a NULL device
1171     * instance path, the following test is required :(
1172     */
1173    if (DeviceNode->Parent->InstancePath.Length == 0)
1174    {
1175       DPRINT1("Parent of %wZ has NULL Instance path, please report!\n",
1176           &DeviceNode->InstancePath);
1177       return STATUS_UNSUCCESSFUL;
1178    }
1179
1180    /* 1. Try to retrieve ParentIdPrefix from registry */
1181    KeyNameBufferLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data[0]) + MAX_PATH * sizeof(WCHAR);
1182    ParentIdPrefixInformation = ExAllocatePool(PagedPool, KeyNameBufferLength + sizeof(WCHAR));
1183    if (!ParentIdPrefixInformation)
1184    {
1185        Status = STATUS_INSUFFICIENT_RESOURCES;
1186        goto cleanup;
1187    }
1188
1189
1190    KeyName.Buffer = ExAllocatePool(PagedPool, (49 * sizeof(WCHAR)) + DeviceNode->Parent->InstancePath.Length);
1191    if (!KeyName.Buffer)
1192    {
1193        Status = STATUS_INSUFFICIENT_RESOURCES;
1194        goto cleanup;
1195    }
1196    KeyName.Length = 0;
1197    KeyName.MaximumLength = (49 * sizeof(WCHAR)) + DeviceNode->Parent->InstancePath.Length;
1198
1199    RtlAppendUnicodeToString(&KeyName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
1200    RtlAppendUnicodeStringToString(&KeyName, &DeviceNode->Parent->InstancePath);
1201
1202    Status = IopOpenRegistryKeyEx(&hKey, NULL, &KeyName, KEY_QUERY_VALUE | KEY_SET_VALUE);
1203    if (!NT_SUCCESS(Status))
1204       goto cleanup;
1205    RtlInitUnicodeString(&ValueName, L"ParentIdPrefix");
1206    Status = ZwQueryValueKey(
1207       hKey, &ValueName,
1208       KeyValuePartialInformation, ParentIdPrefixInformation,
1209       KeyNameBufferLength, &KeyNameBufferLength);
1210    if (NT_SUCCESS(Status))
1211    {
1212       if (ParentIdPrefixInformation->Type != REG_SZ)
1213          Status = STATUS_UNSUCCESSFUL;
1214       else
1215       {
1216          KeyValue.Length = KeyValue.MaximumLength = (USHORT)ParentIdPrefixInformation->DataLength;
1217          KeyValue.Buffer = (PWSTR)ParentIdPrefixInformation->Data;
1218       }
1219       goto cleanup;
1220    }
1221    if (Status != STATUS_OBJECT_NAME_NOT_FOUND)
1222    {
1223       KeyValue.Length = KeyValue.MaximumLength = (USHORT)ParentIdPrefixInformation->DataLength;
1224       KeyValue.Buffer = (PWSTR)ParentIdPrefixInformation->Data;
1225       goto cleanup;
1226    }
1227
1228    /* 2. Create the ParentIdPrefix value */
1229    crc32 = RtlComputeCrc32(0,
1230                            (PUCHAR)DeviceNode->Parent->InstancePath.Buffer,
1231                            DeviceNode->Parent->InstancePath.Length);
1232
1233    swprintf((PWSTR)ParentIdPrefixInformation->Data, L"%lx&%lx", DeviceNode->Parent->Level, crc32);
1234    RtlInitUnicodeString(&KeyValue, (PWSTR)ParentIdPrefixInformation->Data);
1235
1236    /* 3. Try to write the ParentIdPrefix to registry */
1237    Status = ZwSetValueKey(hKey,
1238                           &ValueName,
1239                           0,
1240                           REG_SZ,
1241                           (PVOID)KeyValue.Buffer,
1242                           (wcslen(KeyValue.Buffer) + 1) * sizeof(WCHAR));
1243
1244 cleanup:
1245    if (NT_SUCCESS(Status))
1246    {
1247       /* Duplicate the string to return it */
1248       Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE, &KeyValue, ParentIdPrefix);
1249    }
1250    ExFreePool(ParentIdPrefixInformation);
1251    RtlFreeUnicodeString(&KeyName);
1252    if (hKey != NULL)
1253       ZwClose(hKey);
1254    return Status;
1255 }
1256
1257
1258 /*
1259  * IopActionInterrogateDeviceStack
1260  *
1261  * Retrieve information for all (direct) child nodes of a parent node.
1262  *
1263  * Parameters
1264  *    DeviceNode
1265  *       Pointer to device node.
1266  *    Context
1267  *       Pointer to parent node to retrieve child node information for.
1268  *
1269  * Remarks
1270  *    We only return a status code indicating an error (STATUS_UNSUCCESSFUL)
1271  *    when we reach a device node which is not a direct child of the device
1272  *    node for which we retrieve information of child nodes for. Any errors
1273  *    that occur is logged instead so that all child services have a chance
1274  *    of being interrogated.
1275  */
1276
1277 NTSTATUS
1278 IopActionInterrogateDeviceStack(PDEVICE_NODE DeviceNode,
1279                                 PVOID Context)
1280 {
1281    IO_STATUS_BLOCK IoStatusBlock;
1282    PDEVICE_NODE ParentDeviceNode;
1283    WCHAR InstancePath[MAX_PATH];
1284    IO_STACK_LOCATION Stack;
1285    NTSTATUS Status;
1286    PWSTR Ptr;
1287    USHORT Length;
1288    USHORT TotalLength;
1289    ULONG RequiredLength;
1290    LCID LocaleId;
1291    HANDLE InstanceKey = NULL;
1292    UNICODE_STRING ValueName;
1293    UNICODE_STRING ParentIdPrefix = { 0, 0, NULL };
1294    DEVICE_CAPABILITIES DeviceCapabilities;
1295
1296    DPRINT("IopActionInterrogateDeviceStack(%p, %p)\n", DeviceNode, Context);
1297    DPRINT("PDO 0x%p\n", DeviceNode->PhysicalDeviceObject);
1298
1299    ParentDeviceNode = (PDEVICE_NODE)Context;
1300
1301    /*
1302     * We are called for the parent too, but we don't need to do special
1303     * handling for this node
1304     */
1305
1306    if (DeviceNode == ParentDeviceNode)
1307    {
1308       DPRINT("Success\n");
1309       return STATUS_SUCCESS;
1310    }
1311
1312    /*
1313     * Make sure this device node is a direct child of the parent device node
1314     * that is given as an argument
1315     */
1316
1317    if (DeviceNode->Parent != ParentDeviceNode)
1318    {
1319       /* Stop the traversal immediately and indicate successful operation */
1320       DPRINT("Stop\n");
1321       return STATUS_UNSUCCESSFUL;
1322    }
1323
1324    /* Get Locale ID */
1325    Status = ZwQueryDefaultLocale(FALSE, &LocaleId);
1326    if (!NT_SUCCESS(Status))
1327    {
1328       DPRINT("ZwQueryDefaultLocale() failed with status 0x%lx\n", Status);
1329       return Status;
1330    }
1331
1332    /*
1333     * FIXME: For critical errors, cleanup and disable device, but always
1334     * return STATUS_SUCCESS.
1335     */
1336
1337    DPRINT("Sending IRP_MN_QUERY_ID.BusQueryDeviceID to device stack\n");
1338
1339    Stack.Parameters.QueryId.IdType = BusQueryDeviceID;
1340    Status = IopInitiatePnpIrp(DeviceNode->PhysicalDeviceObject,
1341                               &IoStatusBlock,
1342                               IRP_MN_QUERY_ID,
1343                               &Stack);
1344    if (NT_SUCCESS(Status))
1345    {
1346       /* Copy the device id string */
1347       wcscpy(InstancePath, (PWSTR)IoStatusBlock.Information);
1348
1349       /*
1350        * FIXME: Check for valid characters, if there is invalid characters
1351        * then bugcheck.
1352        */
1353    }
1354    else
1355    {
1356       DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1357    }
1358
1359    DPRINT("Sending IRP_MN_QUERY_CAPABILITIES to device stack\n");
1360
1361    Status = IopQueryDeviceCapabilities(DeviceNode, &DeviceCapabilities);
1362    if (!NT_SUCCESS(Status))
1363    {
1364       DPRINT("IopInitiatePnpIrp() failed (Status 0x%08lx)\n", Status);
1365    }
1366
1367    DeviceNode->CapabilityFlags = *(PULONG)((ULONG_PTR)&DeviceCapabilities + 4);
1368
1369    if (!DeviceCapabilities.UniqueID)
1370    {
1371       /* Device has not a unique ID. We need to prepend parent bus unique identifier */
1372       DPRINT("Instance ID is not unique\n");
1373       Status = IopGetParentIdPrefix(DeviceNode, &ParentIdPrefix);
1374       if (!NT_SUCCESS(Status))
1375       {
1376          DPRINT("IopGetParentIdPrefix() failed (Status 0x%08lx)\n", Status);
1377       }
1378    }
1379
1380    DPRINT("Sending IRP_MN_QUERY_ID.BusQueryInstanceID to device stack\n");
1381
1382    Stack.Parameters.QueryId.IdType = BusQueryInstanceID;
1383    Status = IopInitiatePnpIrp(DeviceNode->PhysicalDeviceObject,
1384                               &IoStatusBlock,
1385                               IRP_MN_QUERY_ID,
1386                               &Stack);
1387    if (NT_SUCCESS(Status))
1388    {
1389       /* Append the instance id string */
1390       wcscat(InstancePath, L"\\");
1391       if (ParentIdPrefix.Length > 0)
1392       {
1393          /* Add information from parent bus device to InstancePath */
1394          wcscat(InstancePath, ParentIdPrefix.Buffer);
1395          if (IoStatusBlock.Information && *(PWSTR)IoStatusBlock.Information)
1396             wcscat(InstancePath, L"&");
1397       }
1398       if (IoStatusBlock.Information)
1399          wcscat(InstancePath, (PWSTR)IoStatusBlock.Information);
1400
1401       /*
1402        * FIXME: Check for valid characters, if there is invalid characters
1403        * then bugcheck
1404        */
1405    }
1406    else
1407    {
1408       DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1409    }
1410    RtlFreeUnicodeString(&ParentIdPrefix);
1411
1412    if (!RtlCreateUnicodeString(&DeviceNode->InstancePath, InstancePath))
1413    {
1414       DPRINT("No resources\n");
1415       /* FIXME: Cleanup and disable device */
1416    }
1417
1418    DPRINT("InstancePath is %S\n", DeviceNode->InstancePath.Buffer);
1419
1420    /*
1421     * Create registry key for the instance id, if it doesn't exist yet
1422     */
1423    Status = IopCreateDeviceKeyPath(&DeviceNode->InstancePath, &InstanceKey);
1424    if (!NT_SUCCESS(Status))
1425    {
1426       DPRINT1("Failed to create the instance key! (Status %lx)\n", Status);
1427    }
1428
1429    {
1430       /* Set 'Capabilities' value */
1431       RtlInitUnicodeString(&ValueName, L"Capabilities");
1432       Status = ZwSetValueKey(InstanceKey,
1433                              &ValueName,
1434                              0,
1435                              REG_DWORD,
1436                              (PVOID)&DeviceNode->CapabilityFlags,
1437                              sizeof(ULONG));
1438
1439       /* Set 'UINumber' value */
1440       if (DeviceCapabilities.UINumber != MAXULONG)
1441       {
1442          RtlInitUnicodeString(&ValueName, L"UINumber");
1443          Status = ZwSetValueKey(InstanceKey,
1444                                 &ValueName,
1445                                 0,
1446                                 REG_DWORD,
1447                                 &DeviceCapabilities.UINumber,
1448                                 sizeof(ULONG));
1449       }
1450    }
1451
1452    DPRINT("Sending IRP_MN_QUERY_ID.BusQueryHardwareIDs to device stack\n");
1453
1454    Stack.Parameters.QueryId.IdType = BusQueryHardwareIDs;
1455    Status = IopInitiatePnpIrp(DeviceNode->PhysicalDeviceObject,
1456                               &IoStatusBlock,
1457                               IRP_MN_QUERY_ID,
1458                               &Stack);
1459    if (NT_SUCCESS(Status))
1460    {
1461       /*
1462        * FIXME: Check for valid characters, if there is invalid characters
1463        * then bugcheck.
1464        */
1465       TotalLength = 0;
1466       Ptr = (PWSTR)IoStatusBlock.Information;
1467       DPRINT("Hardware IDs:\n");
1468       while (*Ptr)
1469       {
1470          DPRINT("  %S\n", Ptr);
1471          Length = wcslen(Ptr) + 1;
1472
1473          Ptr += Length;
1474          TotalLength += Length;
1475       }
1476       DPRINT("TotalLength: %hu\n", TotalLength);
1477       DPRINT("\n");
1478
1479       RtlInitUnicodeString(&ValueName, L"HardwareID");
1480       Status = ZwSetValueKey(InstanceKey,
1481                              &ValueName,
1482                              0,
1483                              REG_MULTI_SZ,
1484                              (PVOID)IoStatusBlock.Information,
1485                              (TotalLength + 1) * sizeof(WCHAR));
1486       if (!NT_SUCCESS(Status))
1487       {
1488          DPRINT1("ZwSetValueKey() failed (Status %lx)\n", Status);
1489       }
1490    }
1491    else
1492    {
1493       DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1494    }
1495
1496    DPRINT("Sending IRP_MN_QUERY_ID.BusQueryCompatibleIDs to device stack\n");
1497
1498    Stack.Parameters.QueryId.IdType = BusQueryCompatibleIDs;
1499    Status = IopInitiatePnpIrp(
1500       DeviceNode->PhysicalDeviceObject,
1501       &IoStatusBlock,
1502       IRP_MN_QUERY_ID,
1503       &Stack);
1504    if (NT_SUCCESS(Status) && IoStatusBlock.Information)
1505    {
1506       /*
1507       * FIXME: Check for valid characters, if there is invalid characters
1508       * then bugcheck.
1509       */
1510       TotalLength = 0;
1511       Ptr = (PWSTR)IoStatusBlock.Information;
1512       DPRINT("Compatible IDs:\n");
1513       while (*Ptr)
1514       {
1515          DPRINT("  %S\n", Ptr);
1516          Length = wcslen(Ptr) + 1;
1517
1518          Ptr += Length;
1519          TotalLength += Length;
1520       }
1521       DPRINT("TotalLength: %hu\n", TotalLength);
1522       DPRINT("\n");
1523
1524       RtlInitUnicodeString(&ValueName, L"CompatibleIDs");
1525       Status = ZwSetValueKey(InstanceKey,
1526          &ValueName,
1527          0,
1528          REG_MULTI_SZ,
1529          (PVOID)IoStatusBlock.Information,
1530          (TotalLength + 1) * sizeof(WCHAR));
1531       if (!NT_SUCCESS(Status))
1532       {
1533          DPRINT1("ZwSetValueKey() failed (Status %lx) or no Compatible ID returned\n", Status);
1534       }
1535    }
1536    else
1537    {
1538       DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1539    }
1540
1541    DPRINT("Sending IRP_MN_QUERY_DEVICE_TEXT.DeviceTextDescription to device stack\n");
1542
1543    Stack.Parameters.QueryDeviceText.DeviceTextType = DeviceTextDescription;
1544    Stack.Parameters.QueryDeviceText.LocaleId = LocaleId;
1545    Status = IopInitiatePnpIrp(
1546       DeviceNode->PhysicalDeviceObject,
1547       &IoStatusBlock,
1548       IRP_MN_QUERY_DEVICE_TEXT,
1549       &Stack);
1550    /* This key is mandatory, so even if the Irp fails, we still write it */
1551    RtlInitUnicodeString(&ValueName, L"DeviceDesc");
1552    if (ZwQueryValueKey(InstanceKey, &ValueName, KeyValueBasicInformation, NULL, 0, &RequiredLength) == STATUS_OBJECT_NAME_NOT_FOUND)
1553    {
1554       if (NT_SUCCESS(Status) &&
1555          IoStatusBlock.Information &&
1556          (*(PWSTR)IoStatusBlock.Information != 0))
1557       {
1558          /* This key is overriden when a driver is installed. Don't write the
1559           * new description if another one already exists */
1560          Status = ZwSetValueKey(InstanceKey,
1561                                 &ValueName,
1562                                 0,
1563                                 REG_SZ,
1564                                 (PVOID)IoStatusBlock.Information,
1565                                 (wcslen((PWSTR)IoStatusBlock.Information) + 1) * sizeof(WCHAR));
1566       }
1567       else
1568       {
1569          UNICODE_STRING DeviceDesc = RTL_CONSTANT_STRING(L"Unknown device");
1570          DPRINT("Driver didn't return DeviceDesc (Status 0x%08lx), so place unknown device there\n", Status);
1571
1572          Status = ZwSetValueKey(InstanceKey,
1573             &ValueName,
1574             0,
1575             REG_SZ,
1576             DeviceDesc.Buffer,
1577             DeviceDesc.MaximumLength);
1578
1579          if (!NT_SUCCESS(Status))
1580          {
1581             DPRINT1("ZwSetValueKey() failed (Status 0x%lx)\n", Status);
1582          }
1583
1584       }
1585    }
1586
1587    DPRINT("Sending IRP_MN_QUERY_DEVICE_TEXT.DeviceTextLocation to device stack\n");
1588
1589    Stack.Parameters.QueryDeviceText.DeviceTextType = DeviceTextLocationInformation;
1590    Stack.Parameters.QueryDeviceText.LocaleId = LocaleId;
1591    Status = IopInitiatePnpIrp(
1592       DeviceNode->PhysicalDeviceObject,
1593       &IoStatusBlock,
1594       IRP_MN_QUERY_DEVICE_TEXT,
1595       &Stack);
1596    if (NT_SUCCESS(Status) && IoStatusBlock.Information)
1597    {
1598       DPRINT("LocationInformation: %S\n", (PWSTR)IoStatusBlock.Information);
1599       RtlInitUnicodeString(&ValueName, L"LocationInformation");
1600       Status = ZwSetValueKey(InstanceKey,
1601          &ValueName,
1602          0,
1603          REG_SZ,
1604          (PVOID)IoStatusBlock.Information,
1605          (wcslen((PWSTR)IoStatusBlock.Information) + 1) * sizeof(WCHAR));
1606       if (!NT_SUCCESS(Status))
1607       {
1608          DPRINT1("ZwSetValueKey() failed (Status %lx)\n", Status);
1609       }
1610    }
1611    else
1612    {
1613       DPRINT("IopInitiatePnpIrp() failed (Status %x) or IoStatusBlock.Information=NULL\n", Status);
1614    }
1615
1616    DPRINT("Sending IRP_MN_QUERY_BUS_INFORMATION to device stack\n");
1617
1618    Status = IopInitiatePnpIrp(
1619       DeviceNode->PhysicalDeviceObject,
1620       &IoStatusBlock,
1621       IRP_MN_QUERY_BUS_INFORMATION,
1622       NULL);
1623    if (NT_SUCCESS(Status) && IoStatusBlock.Information)
1624    {
1625       PPNP_BUS_INFORMATION BusInformation =
1626          (PPNP_BUS_INFORMATION)IoStatusBlock.Information;
1627
1628       DeviceNode->ChildBusNumber = BusInformation->BusNumber;
1629       DeviceNode->ChildInterfaceType = BusInformation->LegacyBusType;
1630       DeviceNode->ChildBusTypeIndex = IopGetBusTypeGuidIndex(&BusInformation->BusTypeGuid);
1631       ExFreePool(BusInformation);
1632    }
1633    else
1634    {
1635       DPRINT("IopInitiatePnpIrp() failed (Status %x) or IoStatusBlock.Information=NULL\n", Status);
1636
1637       DeviceNode->ChildBusNumber = 0xFFFFFFF0;
1638       DeviceNode->ChildInterfaceType = InterfaceTypeUndefined;
1639       DeviceNode->ChildBusTypeIndex = -1;
1640    }
1641
1642    DPRINT("Sending IRP_MN_QUERY_RESOURCES to device stack\n");
1643
1644    Status = IopInitiatePnpIrp(
1645       DeviceNode->PhysicalDeviceObject,
1646       &IoStatusBlock,
1647       IRP_MN_QUERY_RESOURCES,
1648       NULL);
1649    if (NT_SUCCESS(Status) && IoStatusBlock.Information)
1650    {
1651       DeviceNode->BootResources =
1652          (PCM_RESOURCE_LIST)IoStatusBlock.Information;
1653       DeviceNode->Flags |= DNF_HAS_BOOT_CONFIG;
1654    }
1655    else
1656    {
1657       DPRINT("IopInitiatePnpIrp() failed (Status %x) or IoStatusBlock.Information=NULL\n", Status);
1658       DeviceNode->BootResources = NULL;
1659    }
1660
1661    DPRINT("Sending IRP_MN_QUERY_RESOURCE_REQUIREMENTS to device stack\n");
1662
1663    Status = IopInitiatePnpIrp(
1664       DeviceNode->PhysicalDeviceObject,
1665       &IoStatusBlock,
1666       IRP_MN_QUERY_RESOURCE_REQUIREMENTS,
1667       NULL);
1668    if (NT_SUCCESS(Status))
1669    {
1670       DeviceNode->ResourceRequirements =
1671          (PIO_RESOURCE_REQUIREMENTS_LIST)IoStatusBlock.Information;
1672       if (IoStatusBlock.Information)
1673          IopDeviceNodeSetFlag(DeviceNode, DNF_RESOURCE_REPORTED);
1674       else
1675          IopDeviceNodeSetFlag(DeviceNode, DNF_NO_RESOURCE_REQUIRED);
1676    }
1677    else
1678    {
1679       DPRINT("IopInitiatePnpIrp() failed (Status %08lx)\n", Status);
1680       DeviceNode->ResourceRequirements = NULL;
1681    }
1682
1683
1684    if (InstanceKey != NULL)
1685    {
1686       IopSetDeviceInstanceData(InstanceKey, DeviceNode);
1687    }
1688
1689    ZwClose(InstanceKey);
1690
1691    IopDeviceNodeSetFlag(DeviceNode, DNF_PROCESSED);
1692
1693    if (!IopDeviceNodeHasFlag(DeviceNode, DNF_LEGACY_DRIVER))
1694    {
1695       /* Report the device to the user-mode pnp manager */
1696       IopQueueTargetDeviceEvent(&GUID_DEVICE_ENUMERATED,
1697                                 &DeviceNode->InstancePath);
1698    }
1699
1700    return STATUS_SUCCESS;
1701 }
1702
1703
1704 NTSTATUS
1705 IopEnumerateDevice(
1706     IN PDEVICE_OBJECT DeviceObject)
1707 {
1708     PDEVICE_NODE DeviceNode = IopGetDeviceNode(DeviceObject);
1709     DEVICETREE_TRAVERSE_CONTEXT Context;
1710     PDEVICE_RELATIONS DeviceRelations;
1711     PDEVICE_OBJECT ChildDeviceObject;
1712     IO_STATUS_BLOCK IoStatusBlock;
1713     PDEVICE_NODE ChildDeviceNode;
1714     IO_STACK_LOCATION Stack;
1715     NTSTATUS Status;
1716     ULONG i;
1717
1718     DPRINT("DeviceObject 0x%p\n", DeviceObject);
1719
1720     DPRINT("Sending GUID_DEVICE_ARRIVAL\n");
1721
1722     /* Report the device to the user-mode pnp manager */
1723     IopQueueTargetDeviceEvent(&GUID_DEVICE_ARRIVAL,
1724                               &DeviceNode->InstancePath);
1725
1726     DPRINT("Sending IRP_MN_QUERY_DEVICE_RELATIONS to device stack\n");
1727
1728     Stack.Parameters.QueryDeviceRelations.Type = BusRelations;
1729
1730     Status = IopInitiatePnpIrp(
1731         DeviceObject,
1732         &IoStatusBlock,
1733         IRP_MN_QUERY_DEVICE_RELATIONS,
1734         &Stack);
1735     if (!NT_SUCCESS(Status) || Status == STATUS_PENDING)
1736     {
1737         DPRINT("IopInitiatePnpIrp() failed with status 0x%08lx\n", Status);
1738         return Status;
1739     }
1740
1741     DeviceRelations = (PDEVICE_RELATIONS)IoStatusBlock.Information;
1742
1743     if (!DeviceRelations)
1744     {
1745         DPRINT("No PDOs\n");
1746         return STATUS_UNSUCCESSFUL;
1747     }
1748
1749     DPRINT("Got %u PDOs\n", DeviceRelations->Count);
1750
1751     /*
1752      * Create device nodes for all discovered devices
1753      */
1754     for (i = 0; i < DeviceRelations->Count; i++)
1755     {
1756         ChildDeviceObject = DeviceRelations->Objects[i];
1757         ASSERT((ChildDeviceObject->Flags & DO_DEVICE_INITIALIZING) == 0);
1758
1759         ChildDeviceNode = IopGetDeviceNode(ChildDeviceObject);
1760         if (!ChildDeviceNode)
1761         {
1762             /* One doesn't exist, create it */
1763             Status = IopCreateDeviceNode(
1764                 DeviceNode,
1765                 ChildDeviceObject,
1766                 NULL,
1767                 &ChildDeviceNode);
1768             if (NT_SUCCESS(Status))
1769             {
1770                 /* Mark the node as enumerated */
1771                 ChildDeviceNode->Flags |= DNF_ENUMERATED;
1772
1773                 /* Mark the DO as bus enumerated */
1774                 ChildDeviceObject->Flags |= DO_BUS_ENUMERATED_DEVICE;
1775             }
1776             else
1777             {
1778                 /* Ignore this DO */
1779                 DPRINT1("IopCreateDeviceNode() failed with status 0x%08x. Skipping PDO %u\n", Status, i);
1780                 ObDereferenceObject(ChildDeviceNode);
1781             }
1782         }
1783         else
1784         {
1785             /* Mark it as enumerated */
1786             ChildDeviceNode->Flags |= DNF_ENUMERATED;
1787             ObDereferenceObject(ChildDeviceObject);
1788         }
1789     }
1790     ExFreePool(DeviceRelations);
1791
1792     /*
1793      * Retrieve information about all discovered children from the bus driver
1794      */
1795     IopInitDeviceTreeTraverseContext(
1796         &Context,
1797         DeviceNode,
1798         IopActionInterrogateDeviceStack,
1799         DeviceNode);
1800
1801     Status = IopTraverseDeviceTree(&Context);
1802     if (!NT_SUCCESS(Status))
1803     {
1804         DPRINT("IopTraverseDeviceTree() failed with status 0x%08lx\n", Status);
1805         return Status;
1806     }
1807
1808     /*
1809      * Retrieve configuration from the registry for discovered children
1810      */
1811     IopInitDeviceTreeTraverseContext(
1812         &Context,
1813         DeviceNode,
1814         IopActionConfigureChildServices,
1815         DeviceNode);
1816
1817     Status = IopTraverseDeviceTree(&Context);
1818     if (!NT_SUCCESS(Status))
1819     {
1820         DPRINT("IopTraverseDeviceTree() failed with status 0x%08lx\n", Status);
1821         return Status;
1822     }
1823
1824     /*
1825      * Initialize services for discovered children.
1826      */
1827     Status = IopInitializePnpServices(DeviceNode);
1828     if (!NT_SUCCESS(Status))
1829     {
1830         DPRINT("IopInitializePnpServices() failed with status 0x%08lx\n", Status);
1831         return Status;
1832     }
1833
1834     DPRINT("IopEnumerateDevice() finished\n");
1835     return STATUS_SUCCESS;
1836 }
1837
1838
1839 /*
1840  * IopActionConfigureChildServices
1841  *
1842  * Retrieve configuration for all (direct) child nodes of a parent node.
1843  *
1844  * Parameters
1845  *    DeviceNode
1846  *       Pointer to device node.
1847  *    Context
1848  *       Pointer to parent node to retrieve child node configuration for.
1849  *
1850  * Remarks
1851  *    We only return a status code indicating an error (STATUS_UNSUCCESSFUL)
1852  *    when we reach a device node which is not a direct child of the device
1853  *    node for which we configure child services for. Any errors that occur is
1854  *    logged instead so that all child services have a chance of beeing
1855  *    configured.
1856  */
1857
1858 NTSTATUS
1859 IopActionConfigureChildServices(PDEVICE_NODE DeviceNode,
1860                                 PVOID Context)
1861 {
1862    RTL_QUERY_REGISTRY_TABLE QueryTable[3];
1863    PDEVICE_NODE ParentDeviceNode;
1864    PUNICODE_STRING Service;
1865    UNICODE_STRING ClassGUID;
1866    NTSTATUS Status;
1867    DEVICE_CAPABILITIES DeviceCaps;
1868
1869    DPRINT("IopActionConfigureChildServices(%p, %p)\n", DeviceNode, Context);
1870
1871    ParentDeviceNode = (PDEVICE_NODE)Context;
1872
1873    /*
1874     * We are called for the parent too, but we don't need to do special
1875     * handling for this node
1876     */
1877    if (DeviceNode == ParentDeviceNode)
1878    {
1879       DPRINT("Success\n");
1880       return STATUS_SUCCESS;
1881    }
1882
1883    /*
1884     * Make sure this device node is a direct child of the parent device node
1885     * that is given as an argument
1886     */
1887    if (DeviceNode->Parent != ParentDeviceNode)
1888    {
1889       /* Stop the traversal immediately and indicate successful operation */
1890       DPRINT("Stop\n");
1891       return STATUS_UNSUCCESSFUL;
1892    }
1893
1894    if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED))
1895    {
1896       WCHAR RegKeyBuffer[MAX_PATH];
1897       UNICODE_STRING RegKey;
1898
1899       RegKey.Length = 0;
1900       RegKey.MaximumLength = sizeof(RegKeyBuffer);
1901       RegKey.Buffer = RegKeyBuffer;
1902
1903       /*
1904        * Retrieve configuration from Enum key
1905        */
1906
1907       Service = &DeviceNode->ServiceName;
1908
1909       RtlZeroMemory(QueryTable, sizeof(QueryTable));
1910       RtlInitUnicodeString(Service, NULL);
1911       RtlInitUnicodeString(&ClassGUID, NULL);
1912
1913       QueryTable[0].Name = L"Service";
1914       QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
1915       QueryTable[0].EntryContext = Service;
1916
1917       QueryTable[1].Name = L"ClassGUID";
1918       QueryTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
1919       QueryTable[1].EntryContext = &ClassGUID;
1920       QueryTable[1].DefaultType = REG_SZ;
1921       QueryTable[1].DefaultData = L"";
1922       QueryTable[1].DefaultLength = 0;
1923
1924       RtlAppendUnicodeToString(&RegKey, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
1925       RtlAppendUnicodeStringToString(&RegKey, &DeviceNode->InstancePath);
1926
1927       Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
1928          RegKey.Buffer, QueryTable, NULL, NULL);
1929
1930       if (!NT_SUCCESS(Status))
1931       {
1932          /* FIXME: Log the error */
1933          DPRINT("Could not retrieve configuration for device %wZ (Status 0x%08x)\n",
1934             &DeviceNode->InstancePath, Status);
1935          IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
1936          return STATUS_SUCCESS;
1937       }
1938
1939       if (Service->Buffer == NULL)
1940       {
1941          if (NT_SUCCESS(IopQueryDeviceCapabilities(DeviceNode, &DeviceCaps)) &&
1942              DeviceCaps.RawDeviceOK)
1943          {
1944             DPRINT1("%wZ is using parent bus driver (%wZ)\n", &DeviceNode->InstancePath, &ParentDeviceNode->ServiceName);
1945
1946             DeviceNode->ServiceName.Length = 0;
1947             DeviceNode->ServiceName.MaximumLength = ParentDeviceNode->ServiceName.MaximumLength;
1948             DeviceNode->ServiceName.Buffer = ExAllocatePool(PagedPool, DeviceNode->ServiceName.MaximumLength);
1949             if (!DeviceNode->ServiceName.Buffer)
1950                 return STATUS_SUCCESS;
1951
1952             RtlCopyUnicodeString(&DeviceNode->ServiceName, &ParentDeviceNode->ServiceName);
1953
1954             IopDeviceNodeSetFlag(DeviceNode, DNF_LEGACY_DRIVER);
1955          }
1956          else if (ClassGUID.Length != 0)
1957          {
1958             /* Device has a ClassGUID value, but no Service value.
1959              * Suppose it is using the NULL driver, so state the
1960              * device is started */
1961             DPRINT1("%wZ is using NULL driver\n", &DeviceNode->InstancePath);
1962             IopDeviceNodeSetFlag(DeviceNode, DNF_STARTED);
1963          }
1964          else
1965          {
1966             IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
1967          }
1968          return STATUS_SUCCESS;
1969       }
1970
1971       DPRINT("Got Service %S\n", Service->Buffer);
1972    }
1973
1974    return STATUS_SUCCESS;
1975 }
1976
1977 /*
1978  * IopActionInitChildServices
1979  *
1980  * Initialize the service for all (direct) child nodes of a parent node
1981  *
1982  * Parameters
1983  *    DeviceNode
1984  *       Pointer to device node.
1985  *    Context
1986  *       Pointer to parent node to initialize child node services for.
1987  *
1988  * Remarks
1989  *    If the driver image for a service is not loaded and initialized
1990  *    it is done here too. We only return a status code indicating an
1991  *    error (STATUS_UNSUCCESSFUL) when we reach a device node which is
1992  *    not a direct child of the device node for which we initialize
1993  *    child services for. Any errors that occur is logged instead so
1994  *    that all child services have a chance of being initialized.
1995  */
1996
1997 NTSTATUS
1998 IopActionInitChildServices(PDEVICE_NODE DeviceNode,
1999                            PVOID Context)
2000 {
2001    PDEVICE_NODE ParentDeviceNode;
2002    NTSTATUS Status;
2003    BOOLEAN BootDrivers = !PnpSystemInit;
2004
2005    DPRINT("IopActionInitChildServices(%p, %p)\n", DeviceNode, Context);
2006
2007    ParentDeviceNode = (PDEVICE_NODE)Context;
2008
2009    /*
2010     * We are called for the parent too, but we don't need to do special
2011     * handling for this node
2012     */
2013    if (DeviceNode == ParentDeviceNode)
2014    {
2015       DPRINT("Success\n");
2016       return STATUS_SUCCESS;
2017    }
2018
2019    /*
2020     * Make sure this device node is a direct child of the parent device node
2021     * that is given as an argument
2022     */
2023 #if 0
2024    if (DeviceNode->Parent != ParentDeviceNode)
2025    {
2026       /*
2027        * Stop the traversal immediately and indicate unsuccessful operation
2028        */
2029       DPRINT("Stop\n");
2030       return STATUS_UNSUCCESSFUL;
2031    }
2032 #endif
2033
2034    if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED) &&
2035        !IopDeviceNodeHasFlag(DeviceNode, DNF_ADDED) &&
2036        !IopDeviceNodeHasFlag(DeviceNode, DNF_STARTED))
2037    {
2038       PLDR_DATA_TABLE_ENTRY ModuleObject;
2039       PDRIVER_OBJECT DriverObject;
2040
2041       /* Get existing DriverObject pointer (in case the driver has
2042          already been loaded and initialized) */
2043       Status = IopGetDriverObject(
2044           &DriverObject,
2045           &DeviceNode->ServiceName,
2046           FALSE);
2047
2048       if (!NT_SUCCESS(Status))
2049       {
2050          /* Driver is not initialized, try to load it */
2051          Status = IopLoadServiceModule(&DeviceNode->ServiceName, &ModuleObject);
2052
2053          if (NT_SUCCESS(Status) || Status == STATUS_IMAGE_ALREADY_LOADED)
2054          {
2055             /* STATUS_IMAGE_ALREADY_LOADED means this driver
2056                was loaded by the bootloader */
2057             if ((Status != STATUS_IMAGE_ALREADY_LOADED) ||
2058                 (Status == STATUS_IMAGE_ALREADY_LOADED && !DriverObject))
2059             {
2060                /* Initialize the driver */
2061                Status = IopInitializeDriverModule(DeviceNode, ModuleObject,
2062                   &DeviceNode->ServiceName, FALSE, &DriverObject);
2063             }
2064             else
2065             {
2066                Status = STATUS_SUCCESS;
2067             }
2068          }
2069          else
2070          {
2071             DPRINT1("IopLoadServiceModule(%wZ) failed with status 0x%08x\n",
2072                     &DeviceNode->ServiceName, Status);
2073          }
2074       }
2075
2076       /* Driver is loaded and initialized at this point */
2077       if (NT_SUCCESS(Status))
2078       {
2079          /* Attach lower level filter drivers. */
2080          IopAttachFilterDrivers(DeviceNode, TRUE);
2081          /* Initialize the function driver for the device node */
2082          Status = IopInitializeDevice(DeviceNode, DriverObject);
2083
2084          if (NT_SUCCESS(Status))
2085          {
2086             /* Attach upper level filter drivers. */
2087             IopAttachFilterDrivers(DeviceNode, FALSE);
2088             IopDeviceNodeSetFlag(DeviceNode, DNF_STARTED);
2089
2090             Status = IopStartDevice(DeviceNode);
2091          }
2092          else
2093          {
2094             DPRINT1("IopInitializeDevice(%wZ) failed with status 0x%08x\n",
2095                     &DeviceNode->InstancePath, Status);
2096          }
2097       }
2098       else
2099       {
2100          /*
2101           * Don't disable when trying to load only boot drivers
2102           */
2103          if (!BootDrivers)
2104          {
2105             IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
2106             IopDeviceNodeSetFlag(DeviceNode, DNF_START_FAILED);
2107             /* FIXME: Log the error (possibly in IopInitializeDeviceNodeService) */
2108             DPRINT1("Initialization of service %S failed (Status %x)\n",
2109               DeviceNode->ServiceName.Buffer, Status);
2110          }
2111       }
2112    }
2113    else
2114    {
2115       DPRINT("Device %wZ is disabled or already initialized\n",
2116          &DeviceNode->InstancePath);
2117    }
2118
2119    return STATUS_SUCCESS;
2120 }
2121
2122 /*
2123  * IopInitializePnpServices
2124  *
2125  * Initialize services for discovered children
2126  *
2127  * Parameters
2128  *    DeviceNode
2129  *       Top device node to start initializing services.
2130  *
2131  * Return Value
2132  *    Status
2133  */
2134 NTSTATUS
2135 IopInitializePnpServices(IN PDEVICE_NODE DeviceNode)
2136 {
2137    DEVICETREE_TRAVERSE_CONTEXT Context;
2138
2139    DPRINT("IopInitializePnpServices(%p)\n", DeviceNode);
2140
2141    IopInitDeviceTreeTraverseContext(
2142       &Context,
2143       DeviceNode,
2144       IopActionInitChildServices,
2145       DeviceNode);
2146
2147    return IopTraverseDeviceTree(&Context);
2148 }
2149
2150 static NTSTATUS INIT_FUNCTION
2151 IopEnumerateDetectedDevices(
2152    IN HANDLE hBaseKey,
2153    IN PUNICODE_STRING RelativePath OPTIONAL,
2154    IN HANDLE hRootKey,
2155    IN BOOLEAN EnumerateSubKeys,
2156    IN PCM_FULL_RESOURCE_DESCRIPTOR ParentBootResources,
2157    IN ULONG ParentBootResourcesLength)
2158 {
2159    UNICODE_STRING IdentifierU = RTL_CONSTANT_STRING(L"Identifier");
2160    UNICODE_STRING DeviceDescU = RTL_CONSTANT_STRING(L"DeviceDesc");
2161    UNICODE_STRING HardwareIDU = RTL_CONSTANT_STRING(L"HardwareID");
2162    UNICODE_STRING ConfigurationDataU = RTL_CONSTANT_STRING(L"Configuration Data");
2163    UNICODE_STRING BootConfigU = RTL_CONSTANT_STRING(L"BootConfig");
2164    UNICODE_STRING LogConfU = RTL_CONSTANT_STRING(L"LogConf");
2165    OBJECT_ATTRIBUTES ObjectAttributes;
2166    HANDLE hDevicesKey = NULL;
2167    HANDLE hDeviceKey = NULL;
2168    HANDLE hLevel1Key, hLevel2Key = NULL, hLogConf;
2169    UNICODE_STRING Level2NameU;
2170    WCHAR Level2Name[5];
2171    ULONG IndexDevice = 0;
2172    ULONG IndexSubKey;
2173    PKEY_BASIC_INFORMATION pDeviceInformation = NULL;
2174    ULONG DeviceInfoLength = sizeof(KEY_BASIC_INFORMATION) + 50 * sizeof(WCHAR);
2175    PKEY_VALUE_PARTIAL_INFORMATION pValueInformation = NULL;
2176    ULONG ValueInfoLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 50 * sizeof(WCHAR);
2177    UNICODE_STRING DeviceName, ValueName;
2178    ULONG RequiredSize;
2179    PCM_FULL_RESOURCE_DESCRIPTOR BootResources = NULL;
2180    ULONG BootResourcesLength;
2181    NTSTATUS Status;
2182
2183    const UNICODE_STRING IdentifierPci = RTL_CONSTANT_STRING(L"PCI");
2184    UNICODE_STRING HardwareIdPci = RTL_CONSTANT_STRING(L"*PNP0A03\0");
2185    static ULONG DeviceIndexPci = 0;
2186    const UNICODE_STRING IdentifierSerial = RTL_CONSTANT_STRING(L"SerialController");
2187    UNICODE_STRING HardwareIdSerial = RTL_CONSTANT_STRING(L"*PNP0501\0");
2188    static ULONG DeviceIndexSerial = 0;
2189    const UNICODE_STRING IdentifierKeyboard = RTL_CONSTANT_STRING(L"KeyboardController");
2190    UNICODE_STRING HardwareIdKeyboard = RTL_CONSTANT_STRING(L"*PNP0303\0");
2191    static ULONG DeviceIndexKeyboard = 0;
2192    const UNICODE_STRING IdentifierMouse = RTL_CONSTANT_STRING(L"PointerController");
2193    UNICODE_STRING HardwareIdMouse = RTL_CONSTANT_STRING(L"*PNP0F13\0");
2194    static ULONG DeviceIndexMouse = 0;
2195    const UNICODE_STRING IdentifierParallel = RTL_CONSTANT_STRING(L"ParallelController");
2196    UNICODE_STRING HardwareIdParallel = RTL_CONSTANT_STRING(L"*PNP0400\0");
2197    static ULONG DeviceIndexParallel = 0;
2198    const UNICODE_STRING IdentifierFloppy = RTL_CONSTANT_STRING(L"FloppyDiskPeripheral");
2199    UNICODE_STRING HardwareIdFloppy = RTL_CONSTANT_STRING(L"*PNP0700\0");
2200    static ULONG DeviceIndexFloppy = 0;
2201    const UNICODE_STRING IdentifierIsa = RTL_CONSTANT_STRING(L"ISA");
2202    UNICODE_STRING HardwareIdIsa = RTL_CONSTANT_STRING(L"*PNP0A00\0");
2203    static ULONG DeviceIndexIsa = 0;
2204    UNICODE_STRING HardwareIdKey;
2205    PUNICODE_STRING pHardwareId;
2206    ULONG DeviceIndex = 0;
2207    BOOLEAN IsDeviceDesc;
2208
2209     if (RelativePath)
2210     {
2211         Status = IopOpenRegistryKeyEx(&hDevicesKey, hBaseKey, RelativePath, KEY_ENUMERATE_SUB_KEYS);
2212         if (!NT_SUCCESS(Status))
2213         {
2214             DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2215             goto cleanup;
2216         }
2217     }
2218     else
2219         hDevicesKey = hBaseKey;
2220
2221    pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2222    if (!pDeviceInformation)
2223    {
2224       DPRINT("ExAllocatePool() failed\n");
2225       Status = STATUS_NO_MEMORY;
2226       goto cleanup;
2227    }
2228
2229    pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2230    if (!pValueInformation)
2231    {
2232       DPRINT("ExAllocatePool() failed\n");
2233       Status = STATUS_NO_MEMORY;
2234       goto cleanup;
2235    }
2236
2237    while (TRUE)
2238    {
2239       Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2240       if (Status == STATUS_NO_MORE_ENTRIES)
2241          break;
2242       else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2243       {
2244          ExFreePool(pDeviceInformation);
2245          DeviceInfoLength = RequiredSize;
2246          pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2247          if (!pDeviceInformation)
2248          {
2249             DPRINT("ExAllocatePool() failed\n");
2250             Status = STATUS_NO_MEMORY;
2251             goto cleanup;
2252          }
2253          Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2254       }
2255       if (!NT_SUCCESS(Status))
2256       {
2257          DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
2258          goto cleanup;
2259       }
2260       IndexDevice++;
2261
2262       /* Open device key */
2263       DeviceName.Length = DeviceName.MaximumLength = (USHORT)pDeviceInformation->NameLength;
2264       DeviceName.Buffer = pDeviceInformation->Name;
2265
2266       Status = IopOpenRegistryKeyEx(&hDeviceKey, hDevicesKey, &DeviceName,
2267           KEY_QUERY_VALUE + (EnumerateSubKeys ? KEY_ENUMERATE_SUB_KEYS : 0));
2268       if (!NT_SUCCESS(Status))
2269       {
2270          DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2271          goto cleanup;
2272       }
2273
2274       /* Read boot resources, and add then to parent ones */
2275       Status = ZwQueryValueKey(hDeviceKey, &ConfigurationDataU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2276       if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2277       {
2278          ExFreePool(pValueInformation);
2279          ValueInfoLength = RequiredSize;
2280          pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2281          if (!pValueInformation)
2282          {
2283             DPRINT("ExAllocatePool() failed\n");
2284             ZwDeleteKey(hLevel2Key);
2285             Status = STATUS_NO_MEMORY;
2286             goto cleanup;
2287          }
2288          Status = ZwQueryValueKey(hDeviceKey, &ConfigurationDataU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2289       }
2290       if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
2291       {
2292          BootResources = ParentBootResources;
2293          BootResourcesLength = ParentBootResourcesLength;
2294       }
2295       else if (!NT_SUCCESS(Status))
2296       {
2297          DPRINT("ZwQueryValueKey() failed with status 0x%08lx\n", Status);
2298          goto nextdevice;
2299       }
2300       else if (pValueInformation->Type != REG_FULL_RESOURCE_DESCRIPTOR)
2301       {
2302          DPRINT("Wrong registry type: got 0x%lx, expected 0x%lx\n", pValueInformation->Type, REG_FULL_RESOURCE_DESCRIPTOR);
2303          goto nextdevice;
2304       }
2305       else
2306       {
2307          static const ULONG Header = FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR, PartialResourceList.PartialDescriptors);
2308
2309          /* Concatenate current resources and parent ones */
2310          if (ParentBootResourcesLength == 0)
2311             BootResourcesLength = pValueInformation->DataLength;
2312          else
2313             BootResourcesLength = ParentBootResourcesLength
2314                + pValueInformation->DataLength
2315                - Header;
2316          BootResources = ExAllocatePool(PagedPool, BootResourcesLength);
2317          if (!BootResources)
2318          {
2319             DPRINT("ExAllocatePool() failed\n");
2320             goto nextdevice;
2321          }
2322          if (ParentBootResourcesLength == 0)
2323          {
2324             RtlCopyMemory(BootResources, pValueInformation->Data, pValueInformation->DataLength);
2325          }
2326          else if (ParentBootResources->PartialResourceList.PartialDescriptors[ParentBootResources->PartialResourceList.Count - 1].Type == CmResourceTypeDeviceSpecific)
2327          {
2328             RtlCopyMemory(BootResources, pValueInformation->Data, pValueInformation->DataLength);
2329             RtlCopyMemory(
2330                (PVOID)((ULONG_PTR)BootResources + pValueInformation->DataLength),
2331                (PVOID)((ULONG_PTR)ParentBootResources + Header),
2332                ParentBootResourcesLength - Header);
2333             BootResources->PartialResourceList.Count += ParentBootResources->PartialResourceList.Count;
2334          }
2335          else
2336          {
2337             RtlCopyMemory(BootResources, pValueInformation->Data, Header);
2338             RtlCopyMemory(
2339                (PVOID)((ULONG_PTR)BootResources + Header),
2340                (PVOID)((ULONG_PTR)ParentBootResources + Header),
2341                ParentBootResourcesLength - Header);
2342             RtlCopyMemory(
2343                (PVOID)((ULONG_PTR)BootResources + ParentBootResourcesLength),
2344                pValueInformation->Data + Header,
2345                pValueInformation->DataLength - Header);
2346             BootResources->PartialResourceList.Count += ParentBootResources->PartialResourceList.Count;
2347          }
2348       }
2349
2350       if (EnumerateSubKeys)
2351       {
2352          IndexSubKey = 0;
2353          while (TRUE)
2354          {
2355             Status = ZwEnumerateKey(hDeviceKey, IndexSubKey, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2356             if (Status == STATUS_NO_MORE_ENTRIES)
2357                break;
2358             else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2359             {
2360                ExFreePool(pDeviceInformation);
2361                DeviceInfoLength = RequiredSize;
2362                pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2363                if (!pDeviceInformation)
2364                {
2365                   DPRINT("ExAllocatePool() failed\n");
2366                   Status = STATUS_NO_MEMORY;
2367                   goto cleanup;
2368                }
2369                Status = ZwEnumerateKey(hDeviceKey, IndexSubKey, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2370             }
2371             if (!NT_SUCCESS(Status))
2372             {
2373                DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
2374                goto cleanup;
2375             }
2376             IndexSubKey++;
2377             DeviceName.Length = DeviceName.MaximumLength = (USHORT)pDeviceInformation->NameLength;
2378             DeviceName.Buffer = pDeviceInformation->Name;
2379
2380             Status = IopEnumerateDetectedDevices(
2381                hDeviceKey,
2382                &DeviceName,
2383                hRootKey,
2384                TRUE,
2385                BootResources,
2386                BootResourcesLength);
2387             if (!NT_SUCCESS(Status))
2388                goto cleanup;
2389          }
2390       }
2391
2392       /* Read identifier */
2393       Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2394       if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2395       {
2396          ExFreePool(pValueInformation);
2397          ValueInfoLength = RequiredSize;
2398          pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2399          if (!pValueInformation)
2400          {
2401             DPRINT("ExAllocatePool() failed\n");
2402             Status = STATUS_NO_MEMORY;
2403             goto cleanup;
2404          }
2405          Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2406       }
2407       if (!NT_SUCCESS(Status))
2408       {
2409          if (Status != STATUS_OBJECT_NAME_NOT_FOUND)
2410          {
2411             DPRINT("ZwQueryValueKey() failed with status 0x%08lx\n", Status);
2412             goto nextdevice;
2413          }
2414          ValueName.Length = ValueName.MaximumLength = 0;
2415       }
2416       else if (pValueInformation->Type != REG_SZ)
2417       {
2418          DPRINT("Wrong registry type: got 0x%lx, expected 0x%lx\n", pValueInformation->Type, REG_SZ);
2419          goto nextdevice;
2420       }
2421       else
2422       {
2423          /* Assign hardware id to this device */
2424          ValueName.Length = ValueName.MaximumLength = (USHORT)pValueInformation->DataLength;
2425          ValueName.Buffer = (PWCHAR)pValueInformation->Data;
2426          if (ValueName.Length >= sizeof(WCHAR) && ValueName.Buffer[ValueName.Length / sizeof(WCHAR) - 1] == UNICODE_NULL)
2427             ValueName.Length -= sizeof(WCHAR);
2428       }
2429
2430       if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierSerial, FALSE) == 0)
2431       {
2432          pHardwareId = &HardwareIdSerial;
2433          DeviceIndex = DeviceIndexSerial++;
2434          IsDeviceDesc = TRUE;
2435       }
2436       else if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierKeyboard, FALSE) == 0)
2437       {
2438          pHardwareId = &HardwareIdKeyboard;
2439          DeviceIndex = DeviceIndexKeyboard++;
2440          IsDeviceDesc = FALSE;
2441       }
2442       else if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierMouse, FALSE) == 0)
2443       {
2444          pHardwareId = &HardwareIdMouse;
2445          DeviceIndex = DeviceIndexMouse++;
2446          IsDeviceDesc = FALSE;
2447       }
2448       else if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierParallel, FALSE) == 0)
2449       {
2450          pHardwareId = &HardwareIdParallel;
2451          DeviceIndex = DeviceIndexParallel++;
2452          IsDeviceDesc = FALSE;
2453       }
2454       else if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierFloppy, FALSE) == 0)
2455       {
2456          pHardwareId = &HardwareIdFloppy;
2457          DeviceIndex = DeviceIndexFloppy++;
2458          IsDeviceDesc = FALSE;
2459       }
2460       else if (NT_SUCCESS(Status))
2461       {
2462          /* Try to also match the device identifier */
2463          if (RtlCompareUnicodeString(&ValueName, &IdentifierPci, FALSE) == 0)
2464          {
2465             pHardwareId = &HardwareIdPci;
2466             DeviceIndex = DeviceIndexPci++;
2467             IsDeviceDesc = FALSE;
2468          }
2469          else if (RtlCompareUnicodeString(&ValueName, &IdentifierIsa, FALSE) == 0)
2470          {
2471             pHardwareId = &HardwareIdIsa;
2472             DeviceIndex = DeviceIndexIsa++;
2473             IsDeviceDesc = FALSE;
2474          }
2475          else
2476          {
2477             DPRINT("Unknown device '%wZ'\n", &ValueName);
2478             goto nextdevice;
2479          }
2480       }
2481       else
2482       {
2483          /* Unknown key path */
2484          DPRINT("Unknown key path '%wZ'\n", RelativePath);
2485          goto nextdevice;
2486       }
2487
2488       /* Prepare hardware id key (hardware id value without final \0) */
2489       HardwareIdKey = *pHardwareId;
2490       HardwareIdKey.Length -= sizeof(UNICODE_NULL);
2491
2492       /* Add the detected device to Root key */
2493       InitializeObjectAttributes(&ObjectAttributes, &HardwareIdKey, OBJ_KERNEL_HANDLE, hRootKey, NULL);
2494       Status = ZwCreateKey(
2495          &hLevel1Key,
2496          KEY_CREATE_SUB_KEY,
2497          &ObjectAttributes,
2498          0,
2499          NULL,
2500          REG_OPTION_NON_VOLATILE,
2501          NULL);
2502       if (!NT_SUCCESS(Status))
2503       {
2504          DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
2505          goto nextdevice;
2506       }
2507       swprintf(Level2Name, L"%04lu", DeviceIndex);
2508       RtlInitUnicodeString(&Level2NameU, Level2Name);
2509       InitializeObjectAttributes(&ObjectAttributes, &Level2NameU, OBJ_KERNEL_HANDLE, hLevel1Key, NULL);
2510       Status = ZwCreateKey(
2511          &hLevel2Key,
2512          KEY_SET_VALUE | KEY_CREATE_SUB_KEY,
2513          &ObjectAttributes,
2514          0,
2515          NULL,
2516          REG_OPTION_NON_VOLATILE,
2517          NULL);
2518       ZwClose(hLevel1Key);
2519       if (!NT_SUCCESS(Status))
2520       {
2521          DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
2522          goto nextdevice;
2523       }
2524       DPRINT("Found %wZ #%lu (%wZ)\n", &ValueName, DeviceIndex, &HardwareIdKey);
2525       if (IsDeviceDesc)
2526       {
2527          Status = ZwSetValueKey(hLevel2Key, &DeviceDescU, 0, REG_SZ, ValueName.Buffer, ValueName.MaximumLength);
2528          if (!NT_SUCCESS(Status))
2529          {
2530             DPRINT("ZwSetValueKey() failed with status 0x%08lx\n", Status);
2531             ZwDeleteKey(hLevel2Key);
2532             goto nextdevice;
2533          }
2534       }
2535       Status = ZwSetValueKey(hLevel2Key, &HardwareIDU, 0, REG_MULTI_SZ, pHardwareId->Buffer, pHardwareId->MaximumLength);
2536       if (!NT_SUCCESS(Status))
2537       {
2538          DPRINT("ZwSetValueKey() failed with status 0x%08lx\n", Status);
2539          ZwDeleteKey(hLevel2Key);
2540          goto nextdevice;
2541       }
2542       /* Create 'LogConf' subkey */
2543       InitializeObjectAttributes(&ObjectAttributes, &LogConfU, OBJ_KERNEL_HANDLE, hLevel2Key, NULL);
2544       Status = ZwCreateKey(
2545          &hLogConf,
2546          KEY_SET_VALUE,
2547          &ObjectAttributes,
2548          0,
2549          NULL,
2550          REG_OPTION_VOLATILE,
2551          NULL);
2552       if (!NT_SUCCESS(Status))
2553       {
2554          DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
2555          ZwDeleteKey(hLevel2Key);
2556          goto nextdevice;
2557       }
2558       if (BootResourcesLength > 0)
2559       {
2560          /* Save boot resources to 'LogConf\BootConfig' */
2561          Status = ZwSetValueKey(hLogConf, &BootConfigU, 0, REG_FULL_RESOURCE_DESCRIPTOR, BootResources, BootResourcesLength);
2562          if (!NT_SUCCESS(Status))
2563          {
2564             DPRINT("ZwSetValueKey() failed with status 0x%08lx\n", Status);
2565             ZwClose(hLogConf);
2566             ZwDeleteKey(hLevel2Key);
2567             goto nextdevice;
2568          }
2569       }
2570       ZwClose(hLogConf);
2571
2572 nextdevice:
2573       if (BootResources && BootResources != ParentBootResources)
2574          ExFreePool(BootResources);
2575       if (hLevel2Key)
2576       {
2577          ZwClose(hLevel2Key);
2578          hLevel2Key = NULL;
2579       }
2580       if (hDeviceKey)
2581       {
2582          ZwClose(hDeviceKey);
2583          hDeviceKey = NULL;
2584       }
2585    }
2586
2587    Status = STATUS_SUCCESS;
2588
2589 cleanup:
2590    if (hDevicesKey && hDevicesKey != hBaseKey)
2591       ZwClose(hDevicesKey);
2592    if (hDeviceKey)
2593       ZwClose(hDeviceKey);
2594    if (pDeviceInformation)
2595       ExFreePool(pDeviceInformation);
2596    if (pValueInformation)
2597       ExFreePool(pValueInformation);
2598    return Status;
2599 }
2600
2601 static BOOLEAN INIT_FUNCTION
2602 IopIsAcpiComputer(VOID)
2603 {
2604 #ifndef ENABLE_ACPI
2605    return FALSE;
2606 #else
2607    UNICODE_STRING MultiKeyPathU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter");
2608    UNICODE_STRING IdentifierU = RTL_CONSTANT_STRING(L"Identifier");
2609    UNICODE_STRING AcpiBiosIdentifier = RTL_CONSTANT_STRING(L"ACPI BIOS");
2610    OBJECT_ATTRIBUTES ObjectAttributes;
2611    PKEY_BASIC_INFORMATION pDeviceInformation = NULL;
2612    ULONG DeviceInfoLength = sizeof(KEY_BASIC_INFORMATION) + 50 * sizeof(WCHAR);
2613    PKEY_VALUE_PARTIAL_INFORMATION pValueInformation = NULL;
2614    ULONG ValueInfoLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 50 * sizeof(WCHAR);
2615    ULONG RequiredSize;
2616    ULONG IndexDevice = 0;
2617    UNICODE_STRING DeviceName, ValueName;
2618    HANDLE hDevicesKey = NULL;
2619    HANDLE hDeviceKey = NULL;
2620    NTSTATUS Status;
2621    BOOLEAN ret = FALSE;
2622
2623    InitializeObjectAttributes(&ObjectAttributes, &MultiKeyPathU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
2624    Status = ZwOpenKey(&hDevicesKey, KEY_ENUMERATE_SUB_KEYS, &ObjectAttributes);
2625    if (!NT_SUCCESS(Status))
2626    {
2627       DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2628       goto cleanup;
2629    }
2630
2631    pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2632    if (!pDeviceInformation)
2633    {
2634       DPRINT("ExAllocatePool() failed\n");
2635       Status = STATUS_NO_MEMORY;
2636       goto cleanup;
2637    }
2638
2639    pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2640    if (!pDeviceInformation)
2641    {
2642       DPRINT("ExAllocatePool() failed\n");
2643       Status = STATUS_NO_MEMORY;
2644       goto cleanup;
2645    }
2646
2647    while (TRUE)
2648    {
2649       Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2650       if (Status == STATUS_NO_MORE_ENTRIES)
2651          break;
2652       else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2653       {
2654          ExFreePool(pDeviceInformation);
2655          DeviceInfoLength = RequiredSize;
2656          pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2657          if (!pDeviceInformation)
2658          {
2659             DPRINT("ExAllocatePool() failed\n");
2660             Status = STATUS_NO_MEMORY;
2661             goto cleanup;
2662          }
2663          Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2664       }
2665       if (!NT_SUCCESS(Status))
2666       {
2667          DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
2668          goto cleanup;
2669       }
2670       IndexDevice++;
2671
2672       /* Open device key */
2673       DeviceName.Length = DeviceName.MaximumLength = pDeviceInformation->NameLength;
2674       DeviceName.Buffer = pDeviceInformation->Name;
2675       InitializeObjectAttributes(&ObjectAttributes, &DeviceName, OBJ_KERNEL_HANDLE, hDevicesKey, NULL);
2676       Status = ZwOpenKey(
2677          &hDeviceKey,
2678          KEY_QUERY_VALUE,
2679          &ObjectAttributes);
2680       if (!NT_SUCCESS(Status))
2681       {
2682          DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2683          goto cleanup;
2684       }
2685
2686       /* Read identifier */
2687       Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2688       if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2689       {
2690          ExFreePool(pValueInformation);
2691          ValueInfoLength = RequiredSize;
2692          pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2693          if (!pValueInformation)
2694          {
2695             DPRINT("ExAllocatePool() failed\n");
2696             Status = STATUS_NO_MEMORY;
2697             goto cleanup;
2698          }
2699          Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2700       }
2701       if (!NT_SUCCESS(Status))
2702       {
2703          DPRINT("ZwQueryValueKey() failed with status 0x%08lx\n", Status);
2704          goto nextdevice;
2705       }
2706       else if (pValueInformation->Type != REG_SZ)
2707       {
2708          DPRINT("Wrong registry type: got 0x%lx, expected 0x%lx\n", pValueInformation->Type, REG_SZ);
2709          goto nextdevice;
2710       }
2711
2712       ValueName.Length = ValueName.MaximumLength = pValueInformation->DataLength;
2713       ValueName.Buffer = (PWCHAR)pValueInformation->Data;
2714       if (ValueName.Length >= sizeof(WCHAR) && ValueName.Buffer[ValueName.Length / sizeof(WCHAR) - 1] == UNICODE_NULL)
2715          ValueName.Length -= sizeof(WCHAR);
2716       if (RtlCompareUnicodeString(&ValueName, &AcpiBiosIdentifier, FALSE) == 0)
2717       {
2718          DPRINT("Found ACPI BIOS\n");
2719          ret = TRUE;
2720          goto cleanup;
2721       }
2722
2723 nextdevice:
2724       ZwClose(hDeviceKey);
2725       hDeviceKey = NULL;
2726    }
2727
2728 cleanup:
2729    if (pDeviceInformation)
2730       ExFreePool(pDeviceInformation);
2731    if (pValueInformation)
2732       ExFreePool(pValueInformation);
2733    if (hDevicesKey)
2734       ZwClose(hDevicesKey);
2735    if (hDeviceKey)
2736       ZwClose(hDeviceKey);
2737    return ret;
2738 #endif
2739 }
2740
2741 static NTSTATUS INIT_FUNCTION
2742 IopUpdateRootKey(VOID)
2743 {
2744    UNICODE_STRING EnumU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Enum");
2745    UNICODE_STRING RootPathU = RTL_CONSTANT_STRING(L"Root");
2746    UNICODE_STRING MultiKeyPathU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter");
2747    UNICODE_STRING DeviceDescU = RTL_CONSTANT_STRING(L"DeviceDesc");
2748    UNICODE_STRING HardwareIDU = RTL_CONSTANT_STRING(L"HardwareID");
2749    UNICODE_STRING LogConfU = RTL_CONSTANT_STRING(L"LogConf");
2750    UNICODE_STRING HalAcpiDevice = RTL_CONSTANT_STRING(L"ACPI_HAL");
2751    UNICODE_STRING HalAcpiId = RTL_CONSTANT_STRING(L"0000");
2752    UNICODE_STRING HalAcpiDeviceDesc = RTL_CONSTANT_STRING(L"HAL ACPI");
2753    UNICODE_STRING HalAcpiHardwareID = RTL_CONSTANT_STRING(L"*PNP0C08\0");
2754    OBJECT_ATTRIBUTES ObjectAttributes;
2755    HANDLE hEnum, hRoot, hHalAcpiDevice, hHalAcpiId, hLogConf;
2756    NTSTATUS Status;
2757
2758    InitializeObjectAttributes(&ObjectAttributes, &EnumU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
2759    Status = ZwCreateKey(&hEnum, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, 0, NULL);
2760    if (!NT_SUCCESS(Status))
2761    {
2762       DPRINT1("ZwCreateKey() failed with status 0x%08lx\n", Status);
2763       return Status;
2764    }
2765
2766    InitializeObjectAttributes(&ObjectAttributes, &RootPathU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hEnum, NULL);
2767    Status = ZwCreateKey(&hRoot, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, 0, NULL);
2768    ZwClose(hEnum);
2769    if (!NT_SUCCESS(Status))
2770    {
2771       DPRINT1("ZwOpenKey() failed with status 0x%08lx\n", Status);
2772       return Status;
2773    }
2774
2775    if (IopIsAcpiComputer())
2776    {
2777       InitializeObjectAttributes(&ObjectAttributes, &HalAcpiDevice, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hRoot, NULL);
2778       Status = ZwCreateKey(&hHalAcpiDevice, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, 0, NULL);
2779       ZwClose(hRoot);
2780       if (!NT_SUCCESS(Status))
2781          return Status;
2782       InitializeObjectAttributes(&ObjectAttributes, &HalAcpiId, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hHalAcpiDevice, NULL);
2783       Status = ZwCreateKey(&hHalAcpiId, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, 0, NULL);
2784       ZwClose(hHalAcpiDevice);
2785       if (!NT_SUCCESS(Status))
2786          return Status;
2787       Status = ZwSetValueKey(hHalAcpiId, &DeviceDescU, 0, REG_SZ, HalAcpiDeviceDesc.Buffer, HalAcpiDeviceDesc.MaximumLength);
2788       if (NT_SUCCESS(Status))
2789          Status = ZwSetValueKey(hHalAcpiId, &HardwareIDU, 0, REG_MULTI_SZ, HalAcpiHardwareID.Buffer, HalAcpiHardwareID.MaximumLength);
2790       if (NT_SUCCESS(Status))
2791       {
2792           InitializeObjectAttributes(&ObjectAttributes, &LogConfU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hHalAcpiId, NULL);
2793           Status = ZwCreateKey(&hLogConf, 0, &ObjectAttributes, 0, NULL, REG_OPTION_VOLATILE, NULL);
2794           if (NT_SUCCESS(Status))
2795               ZwClose(hLogConf);
2796       }
2797       ZwClose(hHalAcpiId);
2798       return Status;
2799    }
2800    else
2801    {
2802         Status = IopOpenRegistryKeyEx(&hEnum, NULL, &MultiKeyPathU, KEY_ENUMERATE_SUB_KEYS);
2803         if (!NT_SUCCESS(Status))
2804         {
2805             /* Nothing to do, don't return with an error status */
2806             DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2807             ZwClose(hRoot);
2808             return STATUS_SUCCESS;
2809         }
2810         Status = IopEnumerateDetectedDevices(
2811             hEnum,
2812             NULL,
2813             hRoot,
2814             TRUE,
2815             NULL,
2816             0);
2817         ZwClose(hEnum);
2818         ZwClose(hRoot);
2819         return Status;
2820    }
2821 }
2822
2823 NTSTATUS
2824 NTAPI
2825 IopOpenRegistryKeyEx(PHANDLE KeyHandle,
2826                      HANDLE ParentKey,
2827                      PUNICODE_STRING Name,
2828                      ACCESS_MASK DesiredAccess)
2829 {
2830     OBJECT_ATTRIBUTES ObjectAttributes;
2831     NTSTATUS Status;
2832
2833     PAGED_CODE();
2834
2835     *KeyHandle = NULL;
2836
2837     InitializeObjectAttributes(&ObjectAttributes,
2838         Name,
2839         OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
2840         ParentKey,
2841         NULL);
2842
2843     Status = ZwOpenKey(KeyHandle, DesiredAccess, &ObjectAttributes);
2844
2845     return Status;
2846 }
2847
2848 NTSTATUS
2849 NTAPI
2850 IopGetRegistryValue(IN HANDLE Handle,
2851                     IN PWSTR ValueName,
2852                     OUT PKEY_VALUE_FULL_INFORMATION *Information)
2853 {
2854     UNICODE_STRING ValueString;
2855     NTSTATUS Status;
2856     PKEY_VALUE_FULL_INFORMATION FullInformation;
2857     ULONG Size;
2858     PAGED_CODE();
2859
2860     RtlInitUnicodeString(&ValueString, ValueName);
2861
2862     Status = ZwQueryValueKey(Handle,
2863                              &ValueString,
2864                              KeyValueFullInformation,
2865                              NULL,
2866                              0,
2867                              &Size);
2868     if ((Status != STATUS_BUFFER_OVERFLOW) &&
2869         (Status != STATUS_BUFFER_TOO_SMALL))
2870     {
2871         return Status;
2872     }
2873
2874     FullInformation = ExAllocatePool(NonPagedPool, Size);
2875     if (!FullInformation) return STATUS_INSUFFICIENT_RESOURCES;
2876
2877     Status = ZwQueryValueKey(Handle,
2878                              &ValueString,
2879                              KeyValueFullInformation,
2880                              FullInformation,
2881                              Size,
2882                              &Size);
2883     if (!NT_SUCCESS(Status))
2884     {
2885         ExFreePool(FullInformation);
2886         return Status;
2887     }
2888
2889     *Information = FullInformation;
2890     return STATUS_SUCCESS;
2891 }
2892
2893 static NTSTATUS INIT_FUNCTION
2894 NTAPI
2895 PnpDriverInitializeEmpty(IN struct _DRIVER_OBJECT *DriverObject, IN PUNICODE_STRING RegistryPath)
2896 {
2897    return STATUS_SUCCESS;
2898 }
2899
2900 VOID INIT_FUNCTION
2901 PnpInit(VOID)
2902 {
2903     PDEVICE_OBJECT Pdo;
2904     NTSTATUS Status;
2905
2906     DPRINT("PnpInit()\n");
2907
2908     KeInitializeSpinLock(&IopDeviceTreeLock);
2909         ExInitializeFastMutex(&IopBusTypeGuidListLock);
2910
2911     /* Initialize the Bus Type GUID List */
2912     IopBusTypeGuidList = ExAllocatePool(NonPagedPool, sizeof(IO_BUS_TYPE_GUID_LIST));
2913     if (!IopBusTypeGuidList) {
2914         DPRINT1("ExAllocatePool() failed\n");
2915         KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, STATUS_NO_MEMORY, 0, 0, 0);
2916     }
2917
2918     RtlZeroMemory(IopBusTypeGuidList, sizeof(IO_BUS_TYPE_GUID_LIST));
2919     ExInitializeFastMutex(&IopBusTypeGuidList->Lock);
2920
2921     /* Initialize PnP-Event notification support */
2922     Status = IopInitPlugPlayEvents();
2923     if (!NT_SUCCESS(Status))
2924     {
2925         DPRINT1("IopInitPlugPlayEvents() failed\n");
2926         KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2927     }
2928
2929     /*
2930     * Create root device node
2931     */
2932
2933     Status = IopCreateDriver(NULL, PnpDriverInitializeEmpty, NULL, 0, 0, &IopRootDriverObject);
2934     if (!NT_SUCCESS(Status))
2935     {
2936         DPRINT1("IoCreateDriverObject() failed\n");
2937         KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2938     }
2939
2940     Status = IoCreateDevice(IopRootDriverObject, 0, NULL, FILE_DEVICE_CONTROLLER,
2941         0, FALSE, &Pdo);
2942     if (!NT_SUCCESS(Status))
2943     {
2944         DPRINT1("IoCreateDevice() failed\n");
2945         KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2946     }
2947
2948     Status = IopCreateDeviceNode(NULL, Pdo, NULL, &IopRootDeviceNode);
2949     if (!NT_SUCCESS(Status))
2950     {
2951         DPRINT1("Insufficient resources\n");
2952         KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2953     }
2954
2955     if (!RtlCreateUnicodeString(&IopRootDeviceNode->InstancePath,
2956         L"HTREE\\ROOT\\0"))
2957     {
2958         DPRINT1("Failed to create the instance path!\n");
2959         KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, STATUS_NO_MEMORY, 0, 0, 0);
2960     }
2961
2962     /* Report the device to the user-mode pnp manager */
2963     IopQueueTargetDeviceEvent(&GUID_DEVICE_ARRIVAL,
2964         &IopRootDeviceNode->InstancePath);
2965
2966     IopRootDeviceNode->PhysicalDeviceObject->Flags |= DO_BUS_ENUMERATED_DEVICE;
2967     PnpRootDriverEntry(IopRootDriverObject, NULL);
2968     IopRootDeviceNode->PhysicalDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
2969     IopRootDriverObject->DriverExtension->AddDevice(
2970         IopRootDriverObject,
2971         IopRootDeviceNode->PhysicalDeviceObject);
2972
2973     /* Move information about devices detected by Freeloader to SYSTEM\CurrentControlSet\Root\ */
2974     Status = IopUpdateRootKey();
2975     if (!NT_SUCCESS(Status))
2976     {
2977         DPRINT1("IopUpdateRootKey() failed\n");
2978         KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2979     }
2980 }
2981
2982 RTL_GENERIC_COMPARE_RESULTS
2983 NTAPI
2984 PiCompareInstancePath(IN PRTL_AVL_TABLE Table,
2985                       IN PVOID FirstStruct,
2986                       IN PVOID SecondStruct)
2987 {
2988     /* FIXME: TODO */
2989     ASSERT(FALSE);
2990     return 0;
2991 }
2992
2993 //
2994 //  The allocation function is called by the generic table package whenever
2995 //  it needs to allocate memory for the table.
2996 //
2997
2998 PVOID
2999 NTAPI
3000 PiAllocateGenericTableEntry(IN PRTL_AVL_TABLE Table,
3001                             IN CLONG ByteSize)
3002 {
3003     /* FIXME: TODO */
3004     ASSERT(FALSE);
3005     return NULL;
3006 }
3007
3008 VOID
3009 NTAPI
3010 PiFreeGenericTableEntry(IN PRTL_AVL_TABLE Table,
3011                         IN PVOID Buffer)
3012 {
3013     /* FIXME: TODO */
3014     ASSERT(FALSE);
3015 }
3016
3017 VOID
3018 NTAPI
3019 PpInitializeDeviceReferenceTable(VOID)
3020 {
3021     /* Setup the guarded mutex and AVL table */
3022     KeInitializeGuardedMutex(&PpDeviceReferenceTableLock);
3023     RtlInitializeGenericTableAvl(
3024         &PpDeviceReferenceTable,
3025         (PRTL_AVL_COMPARE_ROUTINE)PiCompareInstancePath,
3026         (PRTL_AVL_ALLOCATE_ROUTINE)PiAllocateGenericTableEntry,
3027         (PRTL_AVL_FREE_ROUTINE)PiFreeGenericTableEntry,
3028         NULL);
3029 }
3030
3031 BOOLEAN
3032 NTAPI
3033 PiInitPhase0(VOID)
3034 {
3035     /* Initialize the resource when accessing device registry data */
3036     ExInitializeResourceLite(&PpRegistryDeviceResource);
3037
3038     /* Setup the device reference AVL table */
3039     PpInitializeDeviceReferenceTable();
3040     return TRUE;
3041 }
3042
3043 BOOLEAN
3044 NTAPI
3045 PpInitSystem(VOID)
3046 {
3047     /* Check the initialization phase */
3048     switch (ExpInitializationPhase)
3049     {
3050     case 0:
3051
3052         /* Do Phase 0 */
3053         return PiInitPhase0();
3054
3055     case 1:
3056
3057         /* Do Phase 1 */
3058         return TRUE;
3059         //return PiInitPhase1();
3060
3061     default:
3062
3063         /* Don't know any other phase! Bugcheck! */
3064         KeBugCheck(UNEXPECTED_INITIALIZATION_CALL);
3065         return FALSE;
3066     }
3067 }
3068
3069 /* PUBLIC FUNCTIONS **********************************************************/
3070
3071 /*
3072  * @unimplemented
3073  */
3074 NTSTATUS
3075 NTAPI
3076 IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject,
3077                     IN DEVICE_REGISTRY_PROPERTY DeviceProperty,
3078                     IN ULONG BufferLength,
3079                     OUT PVOID PropertyBuffer,
3080                     OUT PULONG ResultLength)
3081 {
3082     PDEVICE_NODE DeviceNode = IopGetDeviceNode(DeviceObject);
3083     DEVICE_CAPABILITIES DeviceCaps;
3084     ULONG Length;
3085     PVOID Data = NULL;
3086     PWSTR Ptr;
3087     NTSTATUS Status;
3088
3089     DPRINT("IoGetDeviceProperty(0x%p %d)\n", DeviceObject, DeviceProperty);
3090
3091     *ResultLength = 0;
3092
3093     if (DeviceNode == NULL)
3094         return STATUS_INVALID_DEVICE_REQUEST;
3095
3096     switch (DeviceProperty)
3097     {
3098     case DevicePropertyBusNumber:
3099         Length = sizeof(ULONG);
3100         Data = &DeviceNode->ChildBusNumber;
3101         break;
3102
3103         /* Complete, untested */
3104     case DevicePropertyBusTypeGuid:
3105         /* Sanity check */
3106         if ((DeviceNode->ChildBusTypeIndex != 0xFFFF) &&
3107             (DeviceNode->ChildBusTypeIndex < IopBusTypeGuidList->GuidCount))
3108         {
3109             /* Return the GUID */
3110             *ResultLength = sizeof(GUID);
3111
3112             /* Check if the buffer given was large enough */
3113             if (BufferLength < *ResultLength)
3114             {
3115                 return STATUS_BUFFER_TOO_SMALL;
3116             }
3117
3118             /* Copy the GUID */
3119             RtlCopyMemory(PropertyBuffer,
3120                 &(IopBusTypeGuidList->Guids[DeviceNode->ChildBusTypeIndex]),
3121                 sizeof(GUID));
3122             return STATUS_SUCCESS;
3123         }
3124         else
3125         {
3126             return STATUS_OBJECT_NAME_NOT_FOUND;
3127         }
3128         break;
3129
3130     case DevicePropertyLegacyBusType:
3131         Length = sizeof(INTERFACE_TYPE);
3132         Data = &DeviceNode->ChildInterfaceType;
3133         break;
3134
3135     case DevicePropertyAddress:
3136         /* Query the device caps */
3137         Status = IopQueryDeviceCapabilities(DeviceNode, &DeviceCaps);
3138         if (NT_SUCCESS(Status) && (DeviceCaps.Address != MAXULONG))
3139         {
3140             /* Return length */
3141             *ResultLength = sizeof(ULONG);
3142
3143             /* Check if the buffer given was large enough */
3144             if (BufferLength < *ResultLength)
3145             {
3146                 return STATUS_BUFFER_TOO_SMALL;
3147             }
3148
3149             /* Return address */
3150             *(PULONG)PropertyBuffer = DeviceCaps.Address;
3151             return STATUS_SUCCESS;
3152         }
3153         else
3154         {
3155             return STATUS_OBJECT_NAME_NOT_FOUND;
3156         }
3157         break;
3158
3159 //    case DevicePropertyUINumber:
3160 //      if (DeviceNode->CapabilityFlags == NULL)
3161 //         return STATUS_INVALID_DEVICE_REQUEST;
3162 //      Length = sizeof(ULONG);
3163 //      Data = &DeviceNode->CapabilityFlags->UINumber;
3164 //      break;
3165
3166     case DevicePropertyClassName:
3167     case DevicePropertyClassGuid:
3168     case DevicePropertyDriverKeyName:
3169     case DevicePropertyManufacturer:
3170     case DevicePropertyFriendlyName:
3171     case DevicePropertyHardwareID:
3172     case DevicePropertyCompatibleIDs:
3173     case DevicePropertyDeviceDescription:
3174     case DevicePropertyLocationInformation:
3175     case DevicePropertyUINumber:
3176         {
3177             LPCWSTR RegistryPropertyName;
3178             UNICODE_STRING EnumRoot = RTL_CONSTANT_STRING(ENUM_ROOT);
3179             UNICODE_STRING ValueName;
3180             KEY_VALUE_PARTIAL_INFORMATION *ValueInformation;
3181             ULONG ValueInformationLength;
3182             HANDLE KeyHandle, EnumRootHandle;
3183             NTSTATUS Status;
3184
3185             switch (DeviceProperty)
3186             {
3187             case DevicePropertyClassName:
3188                 RegistryPropertyName = L"Class"; break;
3189             case DevicePropertyClassGuid:
3190                 RegistryPropertyName = L"ClassGuid"; break;
3191             case DevicePropertyDriverKeyName:
3192                 RegistryPropertyName = L"Driver"; break;
3193             case DevicePropertyManufacturer:
3194                 RegistryPropertyName = L"Mfg"; break;
3195             case DevicePropertyFriendlyName:
3196                 RegistryPropertyName = L"FriendlyName"; break;
3197             case DevicePropertyHardwareID:
3198                 RegistryPropertyName = L"HardwareID"; break;
3199             case DevicePropertyCompatibleIDs:
3200                 RegistryPropertyName = L"CompatibleIDs"; break;
3201             case DevicePropertyDeviceDescription:
3202                 RegistryPropertyName = L"DeviceDesc"; break;
3203             case DevicePropertyLocationInformation:
3204                 RegistryPropertyName = L"LocationInformation"; break;
3205             case DevicePropertyUINumber:
3206                 RegistryPropertyName = L"UINumber"; break;
3207             default:
3208                 /* Should not happen */
3209                 ASSERT(FALSE);
3210                 return STATUS_UNSUCCESSFUL;
3211             }
3212
3213             DPRINT("Registry property %S\n", RegistryPropertyName);
3214
3215             /* Open Enum key */
3216             Status = IopOpenRegistryKeyEx(&EnumRootHandle, NULL,
3217                 &EnumRoot, KEY_READ);
3218             if (!NT_SUCCESS(Status))
3219             {
3220                 DPRINT1("Error opening ENUM_ROOT, Status=0x%08x\n", Status);
3221                 return Status;
3222             }
3223
3224             /* Open instance key */
3225             Status = IopOpenRegistryKeyEx(&KeyHandle, EnumRootHandle,
3226                 &DeviceNode->InstancePath, KEY_READ);
3227             if (!NT_SUCCESS(Status))
3228             {
3229                 DPRINT1("Error opening InstancePath, Status=0x%08x\n", Status);
3230                 ZwClose(EnumRootHandle);
3231                 return Status;
3232             }
3233
3234             /* Allocate buffer to read as much data as required by the caller */
3235             ValueInformationLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,
3236                 Data[0]) + BufferLength;
3237             ValueInformation = ExAllocatePool(PagedPool, ValueInformationLength);
3238             if (!ValueInformation)
3239             {
3240                 ZwClose(KeyHandle);
3241                 return STATUS_INSUFFICIENT_RESOURCES;
3242             }
3243
3244             /* Read the value */
3245             RtlInitUnicodeString(&ValueName, RegistryPropertyName);
3246             Status = ZwQueryValueKey(KeyHandle, &ValueName,
3247                 KeyValuePartialInformation, ValueInformation,
3248                 ValueInformationLength,
3249                 &ValueInformationLength);
3250             ZwClose(KeyHandle);
3251
3252             /* Return data */
3253             *ResultLength = ValueInformation->DataLength;
3254
3255             if (!NT_SUCCESS(Status))
3256             {
3257                 ExFreePool(ValueInformation);
3258                 if (Status == STATUS_BUFFER_OVERFLOW)
3259                     return STATUS_BUFFER_TOO_SMALL;
3260                 DPRINT1("Problem: Status=0x%08x, ResultLength = %d\n", Status, *ResultLength);
3261                 return Status;
3262             }
3263
3264             /* FIXME: Verify the value (NULL-terminated, correct format). */
3265             RtlCopyMemory(PropertyBuffer, ValueInformation->Data,
3266                 ValueInformation->DataLength);
3267             ExFreePool(ValueInformation);
3268
3269             return STATUS_SUCCESS;
3270         }
3271
3272     case DevicePropertyBootConfiguration:
3273         Length = 0;
3274         if (DeviceNode->BootResources->Count != 0)
3275         {
3276             Length = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
3277         }
3278         Data = DeviceNode->BootResources;
3279         break;
3280
3281         /* FIXME: use a translated boot configuration instead */
3282     case DevicePropertyBootConfigurationTranslated:
3283         Length = 0;
3284         if (DeviceNode->BootResources->Count != 0)
3285         {
3286             Length = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
3287         }
3288         Data = DeviceNode->BootResources;
3289         break;
3290
3291     case DevicePropertyEnumeratorName:
3292         /* A buffer overflow can't happen here, since InstancePath
3293         * always contains the enumerator name followed by \\ */
3294         Ptr = wcschr(DeviceNode->InstancePath.Buffer, L'\\');
3295         ASSERT(Ptr);
3296         Length = (Ptr - DeviceNode->InstancePath.Buffer) * sizeof(WCHAR);
3297         Data = DeviceNode->InstancePath.Buffer;
3298         break;
3299
3300     case DevicePropertyPhysicalDeviceObjectName:
3301         /* InstancePath buffer is NULL terminated, so we can do this */
3302         Length = DeviceNode->InstancePath.MaximumLength;
3303         Data = DeviceNode->InstancePath.Buffer;
3304         break;
3305
3306     default:
3307         return STATUS_INVALID_PARAMETER_2;
3308     }
3309
3310     /* Prepare returned values */
3311     *ResultLength = Length;
3312     if (BufferLength < Length)
3313         return STATUS_BUFFER_TOO_SMALL;
3314     RtlCopyMemory(PropertyBuffer, Data, Length);
3315
3316     /* NULL terminate the string (if required) */
3317     if (DeviceProperty == DevicePropertyEnumeratorName)
3318         ((LPWSTR)PropertyBuffer)[Length / sizeof(WCHAR)] = UNICODE_NULL;
3319
3320     return STATUS_SUCCESS;
3321 }
3322
3323 /*
3324  * @unimplemented
3325  */
3326 VOID
3327 NTAPI
3328 IoInvalidateDeviceState(IN PDEVICE_OBJECT PhysicalDeviceObject)
3329 {
3330     UNIMPLEMENTED;
3331 }
3332
3333 /**
3334  * @name IoOpenDeviceRegistryKey
3335  *
3336  * Open a registry key unique for a specified driver or device instance.
3337  *
3338  * @param DeviceObject   Device to get the registry key for.
3339  * @param DevInstKeyType Type of the key to return.
3340  * @param DesiredAccess  Access mask (eg. KEY_READ | KEY_WRITE).
3341  * @param DevInstRegKey  Handle to the opened registry key on
3342  *                       successful return.
3343  *
3344  * @return Status.
3345  *
3346  * @implemented
3347  */
3348 NTSTATUS
3349 NTAPI
3350 IoOpenDeviceRegistryKey(IN PDEVICE_OBJECT DeviceObject,
3351                         IN ULONG DevInstKeyType,
3352                         IN ACCESS_MASK DesiredAccess,
3353                         OUT PHANDLE DevInstRegKey)
3354 {
3355    static WCHAR RootKeyName[] =
3356       L"\\Registry\\Machine\\System\\CurrentControlSet\\";
3357    static WCHAR ProfileKeyName[] =
3358       L"Hardware Profiles\\Current\\System\\CurrentControlSet\\";
3359    static WCHAR ClassKeyName[] = L"Control\\Class\\";
3360    static WCHAR EnumKeyName[] = L"Enum\\";
3361    static WCHAR DeviceParametersKeyName[] = L"Device Parameters";
3362    ULONG KeyNameLength;
3363    LPWSTR KeyNameBuffer;
3364    UNICODE_STRING KeyName;
3365    ULONG DriverKeyLength;
3366    OBJECT_ATTRIBUTES ObjectAttributes;
3367    PDEVICE_NODE DeviceNode = NULL;
3368    NTSTATUS Status;
3369
3370    DPRINT("IoOpenDeviceRegistryKey() called\n");
3371
3372    if ((DevInstKeyType & (PLUGPLAY_REGKEY_DEVICE | PLUGPLAY_REGKEY_DRIVER)) == 0)
3373    {
3374        DPRINT1("IoOpenDeviceRegistryKey(): got wrong params, exiting... \n");
3375        return STATUS_INVALID_PARAMETER;
3376    }
3377
3378    /*
3379     * Calculate the length of the base key name. This is the full
3380     * name for driver key or the name excluding "Device Parameters"
3381     * subkey for device key.
3382     */
3383
3384    KeyNameLength = sizeof(RootKeyName);
3385    if (DevInstKeyType & PLUGPLAY_REGKEY_CURRENT_HWPROFILE)
3386       KeyNameLength += sizeof(ProfileKeyName) - sizeof(UNICODE_NULL);
3387    if (DevInstKeyType & PLUGPLAY_REGKEY_DRIVER)
3388    {
3389       KeyNameLength += sizeof(ClassKeyName) - sizeof(UNICODE_NULL);
3390       Status = IoGetDeviceProperty(DeviceObject, DevicePropertyDriverKeyName,
3391                                    0, NULL, &DriverKeyLength);
3392       if (Status != STATUS_BUFFER_TOO_SMALL)
3393          return Status;
3394       KeyNameLength += DriverKeyLength;
3395    }
3396    else
3397    {
3398       DeviceNode = IopGetDeviceNode(DeviceObject);
3399       KeyNameLength += sizeof(EnumKeyName) - sizeof(UNICODE_NULL) +
3400                        DeviceNode->InstancePath.Length;
3401    }
3402
3403    /*
3404     * Now allocate the buffer for the key name...
3405     */
3406
3407    KeyNameBuffer = ExAllocatePool(PagedPool, KeyNameLength);
3408    if (KeyNameBuffer == NULL)
3409       return STATUS_INSUFFICIENT_RESOURCES;
3410
3411    KeyName.Length = 0;
3412    KeyName.MaximumLength = (USHORT)KeyNameLength;
3413    KeyName.Buffer = KeyNameBuffer;
3414
3415    /*
3416     * ...and build the key name.
3417     */
3418
3419    KeyName.Length += sizeof(RootKeyName) - sizeof(UNICODE_NULL);
3420    RtlCopyMemory(KeyNameBuffer, RootKeyName, KeyName.Length);
3421
3422    if (DevInstKeyType & PLUGPLAY_REGKEY_CURRENT_HWPROFILE)
3423       RtlAppendUnicodeToString(&KeyName, ProfileKeyName);
3424
3425    if (DevInstKeyType & PLUGPLAY_REGKEY_DRIVER)
3426    {
3427       RtlAppendUnicodeToString(&KeyName, ClassKeyName);
3428       Status = IoGetDeviceProperty(DeviceObject, DevicePropertyDriverKeyName,
3429                                    DriverKeyLength, KeyNameBuffer +
3430                                    (KeyName.Length / sizeof(WCHAR)),
3431                                    &DriverKeyLength);
3432       if (!NT_SUCCESS(Status))
3433       {
3434          DPRINT1("Call to IoGetDeviceProperty() failed with Status 0x%08lx\n", Status);
3435          ExFreePool(KeyNameBuffer);
3436          return Status;
3437       }
3438       KeyName.Length += (USHORT)DriverKeyLength - sizeof(UNICODE_NULL);
3439    }
3440    else
3441    {
3442       RtlAppendUnicodeToString(&KeyName, EnumKeyName);
3443       Status = RtlAppendUnicodeStringToString(&KeyName, &DeviceNode->InstancePath);
3444       if (DeviceNode->InstancePath.Length == 0)
3445       {
3446          ExFreePool(KeyNameBuffer);
3447          return Status;
3448       }
3449    }
3450
3451    /*
3452     * Open the base key.
3453     */
3454    Status = IopOpenRegistryKeyEx(DevInstRegKey, NULL, &KeyName, DesiredAccess);
3455    if (!NT_SUCCESS(Status))
3456    {
3457       DPRINT1("IoOpenDeviceRegistryKey(%wZ): Base key doesn't exist, exiting... (Status 0x%08lx)\n", &KeyName, Status);
3458       ExFreePool(KeyNameBuffer);
3459       return Status;
3460    }
3461    ExFreePool(KeyNameBuffer);
3462
3463    /*
3464     * For driver key we're done now.
3465     */
3466
3467    if (DevInstKeyType & PLUGPLAY_REGKEY_DRIVER)
3468       return Status;
3469
3470    /*
3471     * Let's go further. For device key we must open "Device Parameters"
3472     * subkey and create it if it doesn't exist yet.
3473     */
3474
3475    RtlInitUnicodeString(&KeyName, DeviceParametersKeyName);
3476    InitializeObjectAttributes(&ObjectAttributes, &KeyName,
3477                               OBJ_CASE_INSENSITIVE, *DevInstRegKey, NULL);
3478    Status = ZwCreateKey(DevInstRegKey, DesiredAccess, &ObjectAttributes,
3479                         0, NULL, REG_OPTION_NON_VOLATILE, NULL);
3480    ZwClose(ObjectAttributes.RootDirectory);
3481
3482    return Status;
3483 }
3484
3485 /*
3486  * @unimplemented
3487  */
3488 VOID
3489 NTAPI
3490 IoRequestDeviceEject(IN PDEVICE_OBJECT PhysicalDeviceObject)
3491 {
3492    UNIMPLEMENTED;
3493 }
3494
3495 /*
3496  * @implemented
3497  */
3498 VOID
3499 NTAPI
3500 IoInvalidateDeviceRelations(
3501     IN PDEVICE_OBJECT DeviceObject,
3502     IN DEVICE_RELATION_TYPE Type)
3503 {
3504     PIO_WORKITEM WorkItem;
3505     PINVALIDATE_DEVICE_RELATION_DATA Data;
3506
3507     Data = ExAllocatePool(PagedPool, sizeof(INVALIDATE_DEVICE_RELATION_DATA));
3508     if (!Data)
3509         return;
3510     WorkItem = IoAllocateWorkItem(DeviceObject);
3511     if (!WorkItem)
3512     {
3513         ExFreePool(Data);
3514         return;
3515     }
3516
3517     ObReferenceObject(DeviceObject);
3518     Data->DeviceObject = DeviceObject;
3519     Data->Type = Type;
3520     Data->WorkItem = WorkItem;
3521
3522     IoQueueWorkItem(
3523         WorkItem,
3524         IopAsynchronousInvalidateDeviceRelations,
3525         DelayedWorkQueue,
3526         Data);
3527 }
3528
3529 /*
3530  * @implemented
3531  */
3532 NTSTATUS
3533 NTAPI
3534 IoSynchronousInvalidateDeviceRelations(
3535     IN PDEVICE_OBJECT DeviceObject,
3536     IN DEVICE_RELATION_TYPE Type)
3537 {
3538     PAGED_CODE();
3539
3540     switch (Type)
3541     {
3542         case BusRelations:
3543             /* Enumerate the device */
3544             return IopEnumerateDevice(DeviceObject);
3545         case PowerRelations:
3546              /* Not handled yet */
3547              return STATUS_NOT_IMPLEMENTED;
3548         case TargetDeviceRelation:
3549             /* Nothing to do */
3550             return STATUS_SUCCESS;
3551         default:
3552             /* Ejection relations are not supported */
3553             return STATUS_NOT_SUPPORTED;
3554     }
3555 }
3556
3557 /*
3558  * @unimplemented
3559  */
3560 BOOLEAN
3561 NTAPI
3562 IoTranslateBusAddress(IN INTERFACE_TYPE InterfaceType,
3563                       IN ULONG BusNumber,
3564                       IN PHYSICAL_ADDRESS BusAddress,
3565                       IN OUT PULONG AddressSpace,
3566                       OUT PPHYSICAL_ADDRESS TranslatedAddress)
3567 {
3568     UNIMPLEMENTED;
3569     return FALSE;
3570 }