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