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 = Stack.Parameters.FilterResourceRequirements.IoResourceRequirementList;
 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 #ifdef ENABLE_ACPI
2170    const UNICODE_STRING IdentifierAcpi = RTL_CONSTANT_STRING(L"ACPI BIOS");
2171    UNICODE_STRING HardwareIdAcpi = RTL_CONSTANT_STRING(L"*PNP0C08\0");
2172    static ULONG DeviceIndexAcpi = 0;
2173 #endif
2174    const UNICODE_STRING IdentifierSerial = RTL_CONSTANT_STRING(L"SerialController");
2175    UNICODE_STRING HardwareIdSerial = RTL_CONSTANT_STRING(L"*PNP0501\0");
2176    static ULONG DeviceIndexSerial = 0;
2177    const UNICODE_STRING IdentifierKeyboard = RTL_CONSTANT_STRING(L"KeyboardController");
2178    UNICODE_STRING HardwareIdKeyboard = RTL_CONSTANT_STRING(L"*PNP0303\0");
2179    static ULONG DeviceIndexKeyboard = 0;
2180    const UNICODE_STRING IdentifierMouse = RTL_CONSTANT_STRING(L"PointerController");
2181    UNICODE_STRING HardwareIdMouse = RTL_CONSTANT_STRING(L"*PNP0F13\0");
2182    static ULONG DeviceIndexMouse = 0;
2183    const UNICODE_STRING IdentifierParallel = RTL_CONSTANT_STRING(L"ParallelController");
2184    UNICODE_STRING HardwareIdParallel = RTL_CONSTANT_STRING(L"*PNP0400\0");
2185    static ULONG DeviceIndexParallel = 0;
2186    const UNICODE_STRING IdentifierFloppy = RTL_CONSTANT_STRING(L"FloppyDiskPeripheral");
2187    UNICODE_STRING HardwareIdFloppy = RTL_CONSTANT_STRING(L"*PNP0700\0");
2188    static ULONG DeviceIndexFloppy = 0;
2189    const UNICODE_STRING IdentifierIsa = RTL_CONSTANT_STRING(L"ISA");
2190    UNICODE_STRING HardwareIdIsa = RTL_CONSTANT_STRING(L"*PNP0A00\0");
2191    static ULONG DeviceIndexIsa = 0;
2192    UNICODE_STRING HardwareIdKey;
2193    PUNICODE_STRING pHardwareId;
2194    ULONG DeviceIndex = 0;
2195    BOOLEAN IsDeviceDesc;
2196
2197     if (RelativePath)
2198     {
2199         Status = IopOpenRegistryKeyEx(&hDevicesKey, hBaseKey, RelativePath, KEY_ENUMERATE_SUB_KEYS);
2200         if (!NT_SUCCESS(Status))
2201         {
2202             DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2203             goto cleanup;
2204         }
2205     }
2206     else
2207         hDevicesKey = hBaseKey;
2208
2209    pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2210    if (!pDeviceInformation)
2211    {
2212       DPRINT("ExAllocatePool() failed\n");
2213       Status = STATUS_NO_MEMORY;
2214       goto cleanup;
2215    }
2216
2217    pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2218    if (!pValueInformation)
2219    {
2220       DPRINT("ExAllocatePool() failed\n");
2221       Status = STATUS_NO_MEMORY;
2222       goto cleanup;
2223    }
2224
2225    while (TRUE)
2226    {
2227       Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2228       if (Status == STATUS_NO_MORE_ENTRIES)
2229          break;
2230       else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2231       {
2232          ExFreePool(pDeviceInformation);
2233          DeviceInfoLength = RequiredSize;
2234          pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2235          if (!pDeviceInformation)
2236          {
2237             DPRINT("ExAllocatePool() failed\n");
2238             Status = STATUS_NO_MEMORY;
2239             goto cleanup;
2240          }
2241          Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2242       }
2243       if (!NT_SUCCESS(Status))
2244       {
2245          DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
2246          goto cleanup;
2247       }
2248       IndexDevice++;
2249
2250       /* Open device key */
2251       DeviceName.Length = DeviceName.MaximumLength = (USHORT)pDeviceInformation->NameLength;
2252       DeviceName.Buffer = pDeviceInformation->Name;
2253
2254       Status = IopOpenRegistryKeyEx(&hDeviceKey, hDevicesKey, &DeviceName,
2255           KEY_QUERY_VALUE + (EnumerateSubKeys ? KEY_ENUMERATE_SUB_KEYS : 0));
2256       if (!NT_SUCCESS(Status))
2257       {
2258          DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2259          goto cleanup;
2260       }
2261
2262       /* Read boot resources, and add then to parent ones */
2263       Status = ZwQueryValueKey(hDeviceKey, &ConfigurationDataU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2264       if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2265       {
2266          ExFreePool(pValueInformation);
2267          ValueInfoLength = RequiredSize;
2268          pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2269          if (!pValueInformation)
2270          {
2271             DPRINT("ExAllocatePool() failed\n");
2272             ZwDeleteKey(hLevel2Key);
2273             Status = STATUS_NO_MEMORY;
2274             goto cleanup;
2275          }
2276          Status = ZwQueryValueKey(hDeviceKey, &ConfigurationDataU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2277       }
2278       if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
2279       {
2280          BootResources = ParentBootResources;
2281          BootResourcesLength = ParentBootResourcesLength;
2282       }
2283       else if (!NT_SUCCESS(Status))
2284       {
2285          DPRINT("ZwQueryValueKey() failed with status 0x%08lx\n", Status);
2286          goto nextdevice;
2287       }
2288       else if (pValueInformation->Type != REG_FULL_RESOURCE_DESCRIPTOR)
2289       {
2290          DPRINT("Wrong registry type: got 0x%lx, expected 0x%lx\n", pValueInformation->Type, REG_FULL_RESOURCE_DESCRIPTOR);
2291          goto nextdevice;
2292       }
2293       else
2294       {
2295          static const ULONG Header = FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR, PartialResourceList.PartialDescriptors);
2296
2297          /* Concatenate current resources and parent ones */
2298          if (ParentBootResourcesLength == 0)
2299             BootResourcesLength = pValueInformation->DataLength;
2300          else
2301             BootResourcesLength = ParentBootResourcesLength
2302                + pValueInformation->DataLength
2303                - Header;
2304          BootResources = ExAllocatePool(PagedPool, BootResourcesLength);
2305          if (!BootResources)
2306          {
2307             DPRINT("ExAllocatePool() failed\n");
2308             goto nextdevice;
2309          }
2310          if (ParentBootResourcesLength == 0)
2311          {
2312             RtlCopyMemory(BootResources, pValueInformation->Data, pValueInformation->DataLength);
2313          }
2314          else if (ParentBootResources->PartialResourceList.PartialDescriptors[ParentBootResources->PartialResourceList.Count - 1].Type == CmResourceTypeDeviceSpecific)
2315          {
2316             RtlCopyMemory(BootResources, pValueInformation->Data, pValueInformation->DataLength);
2317             RtlCopyMemory(
2318                (PVOID)((ULONG_PTR)BootResources + pValueInformation->DataLength),
2319                (PVOID)((ULONG_PTR)ParentBootResources + Header),
2320                ParentBootResourcesLength - Header);
2321             BootResources->PartialResourceList.Count += ParentBootResources->PartialResourceList.Count;
2322          }
2323          else
2324          {
2325             RtlCopyMemory(BootResources, pValueInformation->Data, Header);
2326             RtlCopyMemory(
2327                (PVOID)((ULONG_PTR)BootResources + Header),
2328                (PVOID)((ULONG_PTR)ParentBootResources + Header),
2329                ParentBootResourcesLength - Header);
2330             RtlCopyMemory(
2331                (PVOID)((ULONG_PTR)BootResources + ParentBootResourcesLength),
2332                pValueInformation->Data + Header,
2333                pValueInformation->DataLength - Header);
2334             BootResources->PartialResourceList.Count += ParentBootResources->PartialResourceList.Count;
2335          }
2336       }
2337
2338       if (EnumerateSubKeys)
2339       {
2340          IndexSubKey = 0;
2341          while (TRUE)
2342          {
2343             Status = ZwEnumerateKey(hDeviceKey, IndexSubKey, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2344             if (Status == STATUS_NO_MORE_ENTRIES)
2345                break;
2346             else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2347             {
2348                ExFreePool(pDeviceInformation);
2349                DeviceInfoLength = RequiredSize;
2350                pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2351                if (!pDeviceInformation)
2352                {
2353                   DPRINT("ExAllocatePool() failed\n");
2354                   Status = STATUS_NO_MEMORY;
2355                   goto cleanup;
2356                }
2357                Status = ZwEnumerateKey(hDeviceKey, IndexSubKey, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2358             }
2359             if (!NT_SUCCESS(Status))
2360             {
2361                DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
2362                goto cleanup;
2363             }
2364             IndexSubKey++;
2365             DeviceName.Length = DeviceName.MaximumLength = (USHORT)pDeviceInformation->NameLength;
2366             DeviceName.Buffer = pDeviceInformation->Name;
2367
2368             Status = IopEnumerateDetectedDevices(
2369                hDeviceKey,
2370                &DeviceName,
2371                hRootKey,
2372                TRUE,
2373                BootResources,
2374                BootResourcesLength);
2375             if (!NT_SUCCESS(Status))
2376                goto cleanup;
2377          }
2378       }
2379
2380       /* Read identifier */
2381       Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2382       if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2383       {
2384          ExFreePool(pValueInformation);
2385          ValueInfoLength = RequiredSize;
2386          pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2387          if (!pValueInformation)
2388          {
2389             DPRINT("ExAllocatePool() failed\n");
2390             Status = STATUS_NO_MEMORY;
2391             goto cleanup;
2392          }
2393          Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2394       }
2395       if (!NT_SUCCESS(Status))
2396       {
2397          if (Status != STATUS_OBJECT_NAME_NOT_FOUND)
2398          {
2399             DPRINT("ZwQueryValueKey() failed with status 0x%08lx\n", Status);
2400             goto nextdevice;
2401          }
2402          ValueName.Length = ValueName.MaximumLength = 0;
2403       }
2404       else if (pValueInformation->Type != REG_SZ)
2405       {
2406          DPRINT("Wrong registry type: got 0x%lx, expected 0x%lx\n", pValueInformation->Type, REG_SZ);
2407          goto nextdevice;
2408       }
2409       else
2410       {
2411          /* Assign hardware id to this device */
2412          ValueName.Length = ValueName.MaximumLength = (USHORT)pValueInformation->DataLength;
2413          ValueName.Buffer = (PWCHAR)pValueInformation->Data;
2414          if (ValueName.Length >= sizeof(WCHAR) && ValueName.Buffer[ValueName.Length / sizeof(WCHAR) - 1] == UNICODE_NULL)
2415             ValueName.Length -= sizeof(WCHAR);
2416       }
2417
2418       if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierSerial, FALSE) == 0)
2419       {
2420          pHardwareId = &HardwareIdSerial;
2421          DeviceIndex = DeviceIndexSerial++;
2422          IsDeviceDesc = TRUE;
2423       }
2424       else if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierKeyboard, FALSE) == 0)
2425       {
2426          pHardwareId = &HardwareIdKeyboard;
2427          DeviceIndex = DeviceIndexKeyboard++;
2428          IsDeviceDesc = FALSE;
2429       }
2430       else if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierMouse, FALSE) == 0)
2431       {
2432          pHardwareId = &HardwareIdMouse;
2433          DeviceIndex = DeviceIndexMouse++;
2434          IsDeviceDesc = FALSE;
2435       }
2436       else if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierParallel, FALSE) == 0)
2437       {
2438          pHardwareId = &HardwareIdParallel;
2439          DeviceIndex = DeviceIndexParallel++;
2440          IsDeviceDesc = FALSE;
2441       }
2442       else if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierFloppy, FALSE) == 0)
2443       {
2444          pHardwareId = &HardwareIdFloppy;
2445          DeviceIndex = DeviceIndexFloppy++;
2446          IsDeviceDesc = FALSE;
2447       }
2448       else if (NT_SUCCESS(Status))
2449       {
2450          /* Try to also match the device identifier */
2451          if (RtlCompareUnicodeString(&ValueName, &IdentifierPci, FALSE) == 0)
2452          {
2453             pHardwareId = &HardwareIdPci;
2454             DeviceIndex = DeviceIndexPci++;
2455             IsDeviceDesc = FALSE;
2456          }
2457          else if (RtlCompareUnicodeString(&ValueName, &IdentifierIsa, FALSE) == 0)
2458          {
2459             pHardwareId = &HardwareIdIsa;
2460             DeviceIndex = DeviceIndexIsa++;
2461             IsDeviceDesc = FALSE;
2462          }
2463 #ifdef ENABLE_ACPI
2464          else if (RtlCompareUnicodeString(&ValueName, &IdentifierAcpi, FALSE) == 0)
2465          {
2466             pHardwareId = &HardwareIdAcpi;
2467             DeviceIndex = DeviceIndexAcpi++;
2468             IsDeviceDesc = FALSE;
2469          }
2470 #endif
2471          else
2472          {
2473             DPRINT("Unknown device '%wZ'\n", &ValueName);
2474             goto nextdevice;
2475          }
2476       }
2477       else
2478       {
2479          /* Unknown key path */
2480          DPRINT("Unknown key path '%wZ'\n", RelativePath);
2481          goto nextdevice;
2482       }
2483
2484       /* Prepare hardware id key (hardware id value without final \0) */
2485       HardwareIdKey = *pHardwareId;
2486       HardwareIdKey.Length -= sizeof(UNICODE_NULL);
2487
2488       /* Add the detected device to Root key */
2489       InitializeObjectAttributes(&ObjectAttributes, &HardwareIdKey, OBJ_KERNEL_HANDLE, hRootKey, NULL);
2490       Status = ZwCreateKey(
2491          &hLevel1Key,
2492          KEY_CREATE_SUB_KEY,
2493          &ObjectAttributes,
2494          0,
2495          NULL,
2496          REG_OPTION_NON_VOLATILE,
2497          NULL);
2498       if (!NT_SUCCESS(Status))
2499       {
2500          DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
2501          goto nextdevice;
2502       }
2503       swprintf(Level2Name, L"%04lu", DeviceIndex);
2504       RtlInitUnicodeString(&Level2NameU, Level2Name);
2505       InitializeObjectAttributes(&ObjectAttributes, &Level2NameU, OBJ_KERNEL_HANDLE, hLevel1Key, NULL);
2506       Status = ZwCreateKey(
2507          &hLevel2Key,
2508          KEY_SET_VALUE | KEY_CREATE_SUB_KEY,
2509          &ObjectAttributes,
2510          0,
2511          NULL,
2512          REG_OPTION_NON_VOLATILE,
2513          NULL);
2514       ZwClose(hLevel1Key);
2515       if (!NT_SUCCESS(Status))
2516       {
2517          DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
2518          goto nextdevice;
2519       }
2520       DPRINT("Found %wZ #%lu (%wZ)\n", &ValueName, DeviceIndex, &HardwareIdKey);
2521       if (IsDeviceDesc)
2522       {
2523          Status = ZwSetValueKey(hLevel2Key, &DeviceDescU, 0, REG_SZ, ValueName.Buffer, ValueName.MaximumLength);
2524          if (!NT_SUCCESS(Status))
2525          {
2526             DPRINT("ZwSetValueKey() failed with status 0x%08lx\n", Status);
2527             ZwDeleteKey(hLevel2Key);
2528             goto nextdevice;
2529          }
2530       }
2531       Status = ZwSetValueKey(hLevel2Key, &HardwareIDU, 0, REG_MULTI_SZ, pHardwareId->Buffer, pHardwareId->MaximumLength);
2532       if (!NT_SUCCESS(Status))
2533       {
2534          DPRINT("ZwSetValueKey() failed with status 0x%08lx\n", Status);
2535          ZwDeleteKey(hLevel2Key);
2536          goto nextdevice;
2537       }
2538       /* Create 'LogConf' subkey */
2539       InitializeObjectAttributes(&ObjectAttributes, &LogConfU, OBJ_KERNEL_HANDLE, hLevel2Key, NULL);
2540       Status = ZwCreateKey(
2541          &hLogConf,
2542          KEY_SET_VALUE,
2543          &ObjectAttributes,
2544          0,
2545          NULL,
2546          REG_OPTION_VOLATILE,
2547          NULL);
2548       if (!NT_SUCCESS(Status))
2549       {
2550          DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
2551          ZwDeleteKey(hLevel2Key);
2552          goto nextdevice;
2553       }
2554       if (BootResourcesLength > 0)
2555       {
2556          /* Save boot resources to 'LogConf\BootConfig' */
2557          Status = ZwSetValueKey(hLogConf, &BootConfigU, 0, REG_FULL_RESOURCE_DESCRIPTOR, BootResources, BootResourcesLength);
2558          if (!NT_SUCCESS(Status))
2559          {
2560             DPRINT("ZwSetValueKey() failed with status 0x%08lx\n", Status);
2561             ZwClose(hLogConf);
2562             ZwDeleteKey(hLevel2Key);
2563             goto nextdevice;
2564          }
2565       }
2566       ZwClose(hLogConf);
2567
2568 nextdevice:
2569       if (BootResources && BootResources != ParentBootResources)
2570          ExFreePool(BootResources);
2571       if (hLevel2Key)
2572       {
2573          ZwClose(hLevel2Key);
2574          hLevel2Key = NULL;
2575       }
2576       if (hDeviceKey)
2577       {
2578          ZwClose(hDeviceKey);
2579          hDeviceKey = NULL;
2580       }
2581    }
2582
2583    Status = STATUS_SUCCESS;
2584
2585 cleanup:
2586    if (hDevicesKey && hDevicesKey != hBaseKey)
2587       ZwClose(hDevicesKey);
2588    if (hDeviceKey)
2589       ZwClose(hDeviceKey);
2590    if (pDeviceInformation)
2591       ExFreePool(pDeviceInformation);
2592    if (pValueInformation)
2593       ExFreePool(pValueInformation);
2594    return Status;
2595 }
2596
2597 static BOOLEAN INIT_FUNCTION
2598 IopIsAcpiComputer(VOID)
2599 {
2600 #ifndef ENABLE_ACPI
2601    return FALSE;
2602 #else
2603    UNICODE_STRING MultiKeyPathU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter");
2604    UNICODE_STRING IdentifierU = RTL_CONSTANT_STRING(L"Identifier");
2605    UNICODE_STRING AcpiBiosIdentifier = RTL_CONSTANT_STRING(L"ACPI BIOS");
2606    OBJECT_ATTRIBUTES ObjectAttributes;
2607    PKEY_BASIC_INFORMATION pDeviceInformation = NULL;
2608    ULONG DeviceInfoLength = sizeof(KEY_BASIC_INFORMATION) + 50 * sizeof(WCHAR);
2609    PKEY_VALUE_PARTIAL_INFORMATION pValueInformation = NULL;
2610    ULONG ValueInfoLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 50 * sizeof(WCHAR);
2611    ULONG RequiredSize;
2612    ULONG IndexDevice = 0;
2613    UNICODE_STRING DeviceName, ValueName;
2614    HANDLE hDevicesKey = NULL;
2615    HANDLE hDeviceKey = NULL;
2616    NTSTATUS Status;
2617    BOOLEAN ret = FALSE;
2618
2619    InitializeObjectAttributes(&ObjectAttributes, &MultiKeyPathU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
2620    Status = ZwOpenKey(&hDevicesKey, KEY_ENUMERATE_SUB_KEYS, &ObjectAttributes);
2621    if (!NT_SUCCESS(Status))
2622    {
2623       DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2624       goto cleanup;
2625    }
2626
2627    pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2628    if (!pDeviceInformation)
2629    {
2630       DPRINT("ExAllocatePool() failed\n");
2631       Status = STATUS_NO_MEMORY;
2632       goto cleanup;
2633    }
2634
2635    pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2636    if (!pDeviceInformation)
2637    {
2638       DPRINT("ExAllocatePool() failed\n");
2639       Status = STATUS_NO_MEMORY;
2640       goto cleanup;
2641    }
2642
2643    while (TRUE)
2644    {
2645       Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2646       if (Status == STATUS_NO_MORE_ENTRIES)
2647          break;
2648       else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2649       {
2650          ExFreePool(pDeviceInformation);
2651          DeviceInfoLength = RequiredSize;
2652          pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2653          if (!pDeviceInformation)
2654          {
2655             DPRINT("ExAllocatePool() failed\n");
2656             Status = STATUS_NO_MEMORY;
2657             goto cleanup;
2658          }
2659          Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2660       }
2661       if (!NT_SUCCESS(Status))
2662       {
2663          DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
2664          goto cleanup;
2665       }
2666       IndexDevice++;
2667
2668       /* Open device key */
2669       DeviceName.Length = DeviceName.MaximumLength = pDeviceInformation->NameLength;
2670       DeviceName.Buffer = pDeviceInformation->Name;
2671       InitializeObjectAttributes(&ObjectAttributes, &DeviceName, OBJ_KERNEL_HANDLE, hDevicesKey, NULL);
2672       Status = ZwOpenKey(
2673          &hDeviceKey,
2674          KEY_QUERY_VALUE,
2675          &ObjectAttributes);
2676       if (!NT_SUCCESS(Status))
2677       {
2678          DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2679          goto cleanup;
2680       }
2681
2682       /* Read identifier */
2683       Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2684       if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2685       {
2686          ExFreePool(pValueInformation);
2687          ValueInfoLength = RequiredSize;
2688          pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2689          if (!pValueInformation)
2690          {
2691             DPRINT("ExAllocatePool() failed\n");
2692             Status = STATUS_NO_MEMORY;
2693             goto cleanup;
2694          }
2695          Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2696       }
2697       if (!NT_SUCCESS(Status))
2698       {
2699          DPRINT("ZwQueryValueKey() failed with status 0x%08lx\n", Status);
2700          goto nextdevice;
2701       }
2702       else if (pValueInformation->Type != REG_SZ)
2703       {
2704          DPRINT("Wrong registry type: got 0x%lx, expected 0x%lx\n", pValueInformation->Type, REG_SZ);
2705          goto nextdevice;
2706       }
2707
2708       ValueName.Length = ValueName.MaximumLength = pValueInformation->DataLength;
2709       ValueName.Buffer = (PWCHAR)pValueInformation->Data;
2710       if (ValueName.Length >= sizeof(WCHAR) && ValueName.Buffer[ValueName.Length / sizeof(WCHAR) - 1] == UNICODE_NULL)
2711          ValueName.Length -= sizeof(WCHAR);
2712       if (RtlCompareUnicodeString(&ValueName, &AcpiBiosIdentifier, FALSE) == 0)
2713       {
2714          DPRINT("Found ACPI BIOS\n");
2715          ret = TRUE;
2716          goto cleanup;
2717       }
2718
2719 nextdevice:
2720       ZwClose(hDeviceKey);
2721       hDeviceKey = NULL;
2722    }
2723
2724 cleanup:
2725    if (pDeviceInformation)
2726       ExFreePool(pDeviceInformation);
2727    if (pValueInformation)
2728       ExFreePool(pValueInformation);
2729    if (hDevicesKey)
2730       ZwClose(hDevicesKey);
2731    if (hDeviceKey)
2732       ZwClose(hDeviceKey);
2733    return ret;
2734 #endif
2735 }
2736
2737 static NTSTATUS INIT_FUNCTION
2738 IopUpdateRootKey(VOID)
2739 {
2740    UNICODE_STRING EnumU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Enum");
2741    UNICODE_STRING RootPathU = RTL_CONSTANT_STRING(L"Root");
2742    UNICODE_STRING MultiKeyPathU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter");
2743    UNICODE_STRING DeviceDescU = RTL_CONSTANT_STRING(L"DeviceDesc");
2744    UNICODE_STRING HardwareIDU = RTL_CONSTANT_STRING(L"HardwareID");
2745    UNICODE_STRING LogConfU = RTL_CONSTANT_STRING(L"LogConf");
2746    UNICODE_STRING HalAcpiDevice = RTL_CONSTANT_STRING(L"ACPI_HAL");
2747    UNICODE_STRING HalAcpiId = RTL_CONSTANT_STRING(L"0000");
2748    UNICODE_STRING HalAcpiDeviceDesc = RTL_CONSTANT_STRING(L"HAL ACPI");
2749    UNICODE_STRING HalAcpiHardwareID = RTL_CONSTANT_STRING(L"*PNP0C08\0");
2750    OBJECT_ATTRIBUTES ObjectAttributes;
2751    HANDLE hEnum, hRoot, hHalAcpiDevice, hHalAcpiId, hLogConf;
2752    NTSTATUS Status;
2753
2754    InitializeObjectAttributes(&ObjectAttributes, &EnumU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
2755    Status = ZwCreateKey(&hEnum, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, 0, NULL);
2756    if (!NT_SUCCESS(Status))
2757    {
2758       DPRINT1("ZwCreateKey() failed with status 0x%08lx\n", Status);
2759       return Status;
2760    }
2761
2762    InitializeObjectAttributes(&ObjectAttributes, &RootPathU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hEnum, NULL);
2763    Status = ZwCreateKey(&hRoot, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, 0, NULL);
2764    ZwClose(hEnum);
2765    if (!NT_SUCCESS(Status))
2766    {
2767       DPRINT1("ZwOpenKey() failed with status 0x%08lx\n", Status);
2768       return Status;
2769    }
2770
2771    if (IopIsAcpiComputer())
2772    {
2773       InitializeObjectAttributes(&ObjectAttributes, &HalAcpiDevice, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hRoot, NULL);
2774       Status = ZwCreateKey(&hHalAcpiDevice, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, 0, NULL);
2775       ZwClose(hRoot);
2776       if (!NT_SUCCESS(Status))
2777          return Status;
2778       InitializeObjectAttributes(&ObjectAttributes, &HalAcpiId, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hHalAcpiDevice, NULL);
2779       Status = ZwCreateKey(&hHalAcpiId, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, 0, NULL);
2780       ZwClose(hHalAcpiDevice);
2781       if (!NT_SUCCESS(Status))
2782          return Status;
2783       Status = ZwSetValueKey(hHalAcpiId, &DeviceDescU, 0, REG_SZ, HalAcpiDeviceDesc.Buffer, HalAcpiDeviceDesc.MaximumLength);
2784       if (NT_SUCCESS(Status))
2785          Status = ZwSetValueKey(hHalAcpiId, &HardwareIDU, 0, REG_MULTI_SZ, HalAcpiHardwareID.Buffer, HalAcpiHardwareID.MaximumLength);
2786       if (NT_SUCCESS(Status))
2787       {
2788           InitializeObjectAttributes(&ObjectAttributes, &LogConfU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hHalAcpiId, NULL);
2789           Status = ZwCreateKey(&hLogConf, 0, &ObjectAttributes, 0, NULL, REG_OPTION_VOLATILE, NULL);
2790           if (NT_SUCCESS(Status))
2791               ZwClose(hLogConf);
2792       }
2793       ZwClose(hHalAcpiId);
2794       return Status;
2795    }
2796    else
2797    {
2798         Status = IopOpenRegistryKeyEx(&hEnum, NULL, &MultiKeyPathU, KEY_ENUMERATE_SUB_KEYS);
2799         if (!NT_SUCCESS(Status))
2800         {
2801             /* Nothing to do, don't return with an error status */
2802             DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2803             ZwClose(hRoot);
2804             return STATUS_SUCCESS;
2805         }
2806         Status = IopEnumerateDetectedDevices(
2807             hEnum,
2808             NULL,
2809             hRoot,
2810             TRUE,
2811             NULL,
2812             0);
2813         ZwClose(hEnum);
2814         ZwClose(hRoot);
2815         return Status;
2816    }
2817 }
2818
2819 NTSTATUS
2820 NTAPI
2821 IopOpenRegistryKeyEx(PHANDLE KeyHandle,
2822                      HANDLE ParentKey,
2823                      PUNICODE_STRING Name,
2824                      ACCESS_MASK DesiredAccess)
2825 {
2826     OBJECT_ATTRIBUTES ObjectAttributes;
2827     NTSTATUS Status;
2828
2829     PAGED_CODE();
2830
2831     *KeyHandle = NULL;
2832
2833     InitializeObjectAttributes(&ObjectAttributes,
2834         Name,
2835         OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
2836         ParentKey,
2837         NULL);
2838
2839     Status = ZwOpenKey(KeyHandle, DesiredAccess, &ObjectAttributes);
2840
2841     return Status;
2842 }
2843
2844 NTSTATUS
2845 NTAPI
2846 IopGetRegistryValue(IN HANDLE Handle,
2847                     IN PWSTR ValueName,
2848                     OUT PKEY_VALUE_FULL_INFORMATION *Information)
2849 {
2850     UNICODE_STRING ValueString;
2851     NTSTATUS Status;
2852     PKEY_VALUE_FULL_INFORMATION FullInformation;
2853     ULONG Size;
2854     PAGED_CODE();
2855
2856     RtlInitUnicodeString(&ValueString, ValueName);
2857
2858     Status = ZwQueryValueKey(Handle,
2859                              &ValueString,
2860                              KeyValueFullInformation,
2861                              NULL,
2862                              0,
2863                              &Size);
2864     if ((Status != STATUS_BUFFER_OVERFLOW) &&
2865         (Status != STATUS_BUFFER_TOO_SMALL))
2866     {
2867         return Status;
2868     }
2869
2870     FullInformation = ExAllocatePool(NonPagedPool, Size);
2871     if (!FullInformation) return STATUS_INSUFFICIENT_RESOURCES;
2872
2873     Status = ZwQueryValueKey(Handle,
2874                              &ValueString,
2875                              KeyValueFullInformation,
2876                              FullInformation,
2877                              Size,
2878                              &Size);
2879     if (!NT_SUCCESS(Status))
2880     {
2881         ExFreePool(FullInformation);
2882         return Status;
2883     }
2884
2885     *Information = FullInformation;
2886     return STATUS_SUCCESS;
2887 }
2888
2889 static NTSTATUS INIT_FUNCTION
2890 NTAPI
2891 PnpDriverInitializeEmpty(IN struct _DRIVER_OBJECT *DriverObject, IN PUNICODE_STRING RegistryPath)
2892 {
2893    return STATUS_SUCCESS;
2894 }
2895
2896 VOID INIT_FUNCTION
2897 PnpInit(VOID)
2898 {
2899     PDEVICE_OBJECT Pdo;
2900     NTSTATUS Status;
2901
2902     DPRINT("PnpInit()\n");
2903
2904     KeInitializeSpinLock(&IopDeviceTreeLock);
2905         ExInitializeFastMutex(&IopBusTypeGuidListLock);
2906
2907     /* Initialize the Bus Type GUID List */
2908     IopBusTypeGuidList = ExAllocatePool(NonPagedPool, sizeof(IO_BUS_TYPE_GUID_LIST));
2909     if (!IopBusTypeGuidList) {
2910         DPRINT1("ExAllocatePool() failed\n");
2911         KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, STATUS_NO_MEMORY, 0, 0, 0);
2912     }
2913
2914     RtlZeroMemory(IopBusTypeGuidList, sizeof(IO_BUS_TYPE_GUID_LIST));
2915     ExInitializeFastMutex(&IopBusTypeGuidList->Lock);
2916
2917     /* Initialize PnP-Event notification support */
2918     Status = IopInitPlugPlayEvents();
2919     if (!NT_SUCCESS(Status))
2920     {
2921         DPRINT1("IopInitPlugPlayEvents() failed\n");
2922         KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2923     }
2924
2925     /*
2926     * Create root device node
2927     */
2928
2929     Status = IopCreateDriver(NULL, PnpDriverInitializeEmpty, NULL, 0, 0, &IopRootDriverObject);
2930     if (!NT_SUCCESS(Status))
2931     {
2932         DPRINT1("IoCreateDriverObject() failed\n");
2933         KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2934     }
2935
2936     Status = IoCreateDevice(IopRootDriverObject, 0, NULL, FILE_DEVICE_CONTROLLER,
2937         0, FALSE, &Pdo);
2938     if (!NT_SUCCESS(Status))
2939     {
2940         DPRINT1("IoCreateDevice() failed\n");
2941         KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2942     }
2943
2944     Status = IopCreateDeviceNode(NULL, Pdo, NULL, &IopRootDeviceNode);
2945     if (!NT_SUCCESS(Status))
2946     {
2947         DPRINT1("Insufficient resources\n");
2948         KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2949     }
2950
2951     if (!RtlCreateUnicodeString(&IopRootDeviceNode->InstancePath,
2952         L"HTREE\\ROOT\\0"))
2953     {
2954         DPRINT1("Failed to create the instance path!\n");
2955         KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, STATUS_NO_MEMORY, 0, 0, 0);
2956     }
2957
2958     /* Report the device to the user-mode pnp manager */
2959     IopQueueTargetDeviceEvent(&GUID_DEVICE_ARRIVAL,
2960         &IopRootDeviceNode->InstancePath);
2961
2962     IopRootDeviceNode->PhysicalDeviceObject->Flags |= DO_BUS_ENUMERATED_DEVICE;
2963     PnpRootDriverEntry(IopRootDriverObject, NULL);
2964     IopRootDeviceNode->PhysicalDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
2965     IopRootDriverObject->DriverExtension->AddDevice(
2966         IopRootDriverObject,
2967         IopRootDeviceNode->PhysicalDeviceObject);
2968
2969     /* Move information about devices detected by Freeloader to SYSTEM\CurrentControlSet\Root\ */
2970     Status = IopUpdateRootKey();
2971     if (!NT_SUCCESS(Status))
2972     {
2973         DPRINT1("IopUpdateRootKey() failed\n");
2974         KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2975     }
2976 }
2977
2978 RTL_GENERIC_COMPARE_RESULTS
2979 NTAPI
2980 PiCompareInstancePath(IN PRTL_AVL_TABLE Table,
2981                       IN PVOID FirstStruct,
2982                       IN PVOID SecondStruct)
2983 {
2984     /* FIXME: TODO */
2985     ASSERT(FALSE);
2986     return 0;
2987 }
2988
2989 //
2990 //  The allocation function is called by the generic table package whenever
2991 //  it needs to allocate memory for the table.
2992 //
2993
2994 PVOID
2995 NTAPI
2996 PiAllocateGenericTableEntry(IN PRTL_AVL_TABLE Table,
2997                             IN CLONG ByteSize)
2998 {
2999     /* FIXME: TODO */
3000     ASSERT(FALSE);
3001     return NULL;
3002 }
3003
3004 VOID
3005 NTAPI
3006 PiFreeGenericTableEntry(IN PRTL_AVL_TABLE Table,
3007                         IN PVOID Buffer)
3008 {
3009     /* FIXME: TODO */
3010     ASSERT(FALSE);
3011 }
3012
3013 VOID
3014 NTAPI
3015 PpInitializeDeviceReferenceTable(VOID)
3016 {
3017     /* Setup the guarded mutex and AVL table */
3018     KeInitializeGuardedMutex(&PpDeviceReferenceTableLock);
3019     RtlInitializeGenericTableAvl(
3020         &PpDeviceReferenceTable,
3021         (PRTL_AVL_COMPARE_ROUTINE)PiCompareInstancePath,
3022         (PRTL_AVL_ALLOCATE_ROUTINE)PiAllocateGenericTableEntry,
3023         (PRTL_AVL_FREE_ROUTINE)PiFreeGenericTableEntry,
3024         NULL);
3025 }
3026
3027 BOOLEAN
3028 NTAPI
3029 PiInitPhase0(VOID)
3030 {
3031     /* Initialize the resource when accessing device registry data */
3032     ExInitializeResourceLite(&PpRegistryDeviceResource);
3033
3034     /* Setup the device reference AVL table */
3035     PpInitializeDeviceReferenceTable();
3036     return TRUE;
3037 }
3038
3039 BOOLEAN
3040 NTAPI
3041 PpInitSystem(VOID)
3042 {
3043     /* Check the initialization phase */
3044     switch (ExpInitializationPhase)
3045     {
3046     case 0:
3047
3048         /* Do Phase 0 */
3049         return PiInitPhase0();
3050
3051     case 1:
3052
3053         /* Do Phase 1 */
3054         return TRUE;
3055         //return PiInitPhase1();
3056
3057     default:
3058
3059         /* Don't know any other phase! Bugcheck! */
3060         KeBugCheck(UNEXPECTED_INITIALIZATION_CALL);
3061         return FALSE;
3062     }
3063 }
3064
3065 /* PUBLIC FUNCTIONS **********************************************************/
3066
3067 /*
3068  * @unimplemented
3069  */
3070 NTSTATUS
3071 NTAPI
3072 IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject,
3073                     IN DEVICE_REGISTRY_PROPERTY DeviceProperty,
3074                     IN ULONG BufferLength,
3075                     OUT PVOID PropertyBuffer,
3076                     OUT PULONG ResultLength)
3077 {
3078     PDEVICE_NODE DeviceNode = IopGetDeviceNode(DeviceObject);
3079     DEVICE_CAPABILITIES DeviceCaps;
3080     ULONG Length;
3081     PVOID Data = NULL;
3082     PWSTR Ptr;
3083     NTSTATUS Status;
3084
3085     DPRINT("IoGetDeviceProperty(0x%p %d)\n", DeviceObject, DeviceProperty);
3086
3087     *ResultLength = 0;
3088
3089     if (DeviceNode == NULL)
3090         return STATUS_INVALID_DEVICE_REQUEST;
3091
3092     switch (DeviceProperty)
3093     {
3094     case DevicePropertyBusNumber:
3095         Length = sizeof(ULONG);
3096         Data = &DeviceNode->ChildBusNumber;
3097         break;
3098
3099         /* Complete, untested */
3100     case DevicePropertyBusTypeGuid:
3101         /* Sanity check */
3102         if ((DeviceNode->ChildBusTypeIndex != 0xFFFF) &&
3103             (DeviceNode->ChildBusTypeIndex < IopBusTypeGuidList->GuidCount))
3104         {
3105             /* Return the GUID */
3106             *ResultLength = sizeof(GUID);
3107
3108             /* Check if the buffer given was large enough */
3109             if (BufferLength < *ResultLength)
3110             {
3111                 return STATUS_BUFFER_TOO_SMALL;
3112             }
3113
3114             /* Copy the GUID */
3115             RtlCopyMemory(PropertyBuffer,
3116                 &(IopBusTypeGuidList->Guids[DeviceNode->ChildBusTypeIndex]),
3117                 sizeof(GUID));
3118             return STATUS_SUCCESS;
3119         }
3120         else
3121         {
3122             return STATUS_OBJECT_NAME_NOT_FOUND;
3123         }
3124         break;
3125
3126     case DevicePropertyLegacyBusType:
3127         Length = sizeof(INTERFACE_TYPE);
3128         Data = &DeviceNode->ChildInterfaceType;
3129         break;
3130
3131     case DevicePropertyAddress:
3132         /* Query the device caps */
3133         Status = IopQueryDeviceCapabilities(DeviceNode, &DeviceCaps);
3134         if (NT_SUCCESS(Status) && (DeviceCaps.Address != MAXULONG))
3135         {
3136             /* Return length */
3137             *ResultLength = sizeof(ULONG);
3138
3139             /* Check if the buffer given was large enough */
3140             if (BufferLength < *ResultLength)
3141             {
3142                 return STATUS_BUFFER_TOO_SMALL;
3143             }
3144
3145             /* Return address */
3146             *(PULONG)PropertyBuffer = DeviceCaps.Address;
3147             return STATUS_SUCCESS;
3148         }
3149         else
3150         {
3151             return STATUS_OBJECT_NAME_NOT_FOUND;
3152         }
3153         break;
3154
3155 //    case DevicePropertyUINumber:
3156 //      if (DeviceNode->CapabilityFlags == NULL)
3157 //         return STATUS_INVALID_DEVICE_REQUEST;
3158 //      Length = sizeof(ULONG);
3159 //      Data = &DeviceNode->CapabilityFlags->UINumber;
3160 //      break;
3161
3162     case DevicePropertyClassName:
3163     case DevicePropertyClassGuid:
3164     case DevicePropertyDriverKeyName:
3165     case DevicePropertyManufacturer:
3166     case DevicePropertyFriendlyName:
3167     case DevicePropertyHardwareID:
3168     case DevicePropertyCompatibleIDs:
3169     case DevicePropertyDeviceDescription:
3170     case DevicePropertyLocationInformation:
3171     case DevicePropertyUINumber:
3172         {
3173             LPCWSTR RegistryPropertyName;
3174             UNICODE_STRING EnumRoot = RTL_CONSTANT_STRING(ENUM_ROOT);
3175             UNICODE_STRING ValueName;
3176             KEY_VALUE_PARTIAL_INFORMATION *ValueInformation;
3177             ULONG ValueInformationLength;
3178             HANDLE KeyHandle, EnumRootHandle;
3179             NTSTATUS Status;
3180
3181             switch (DeviceProperty)
3182             {
3183             case DevicePropertyClassName:
3184                 RegistryPropertyName = L"Class"; break;
3185             case DevicePropertyClassGuid:
3186                 RegistryPropertyName = L"ClassGuid"; break;
3187             case DevicePropertyDriverKeyName:
3188                 RegistryPropertyName = L"Driver"; break;
3189             case DevicePropertyManufacturer:
3190                 RegistryPropertyName = L"Mfg"; break;
3191             case DevicePropertyFriendlyName:
3192                 RegistryPropertyName = L"FriendlyName"; break;
3193             case DevicePropertyHardwareID:
3194                 RegistryPropertyName = L"HardwareID"; break;
3195             case DevicePropertyCompatibleIDs:
3196                 RegistryPropertyName = L"CompatibleIDs"; break;
3197             case DevicePropertyDeviceDescription:
3198                 RegistryPropertyName = L"DeviceDesc"; break;
3199             case DevicePropertyLocationInformation:
3200                 RegistryPropertyName = L"LocationInformation"; break;
3201             case DevicePropertyUINumber:
3202                 RegistryPropertyName = L"UINumber"; break;
3203             default:
3204                 /* Should not happen */
3205                 ASSERT(FALSE);
3206                 return STATUS_UNSUCCESSFUL;
3207             }
3208
3209             DPRINT("Registry property %S\n", RegistryPropertyName);
3210
3211             /* Open Enum key */
3212             Status = IopOpenRegistryKeyEx(&EnumRootHandle, NULL,
3213                 &EnumRoot, KEY_READ);
3214             if (!NT_SUCCESS(Status))
3215             {
3216                 DPRINT1("Error opening ENUM_ROOT, Status=0x%08x\n", Status);
3217                 return Status;
3218             }
3219
3220             /* Open instance key */
3221             Status = IopOpenRegistryKeyEx(&KeyHandle, EnumRootHandle,
3222                 &DeviceNode->InstancePath, KEY_READ);
3223             if (!NT_SUCCESS(Status))
3224             {
3225                 DPRINT1("Error opening InstancePath, Status=0x%08x\n", Status);
3226                 ZwClose(EnumRootHandle);
3227                 return Status;
3228             }
3229
3230             /* Allocate buffer to read as much data as required by the caller */
3231             ValueInformationLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,
3232                 Data[0]) + BufferLength;
3233             ValueInformation = ExAllocatePool(PagedPool, ValueInformationLength);
3234             if (!ValueInformation)
3235             {
3236                 ZwClose(KeyHandle);
3237                 return STATUS_INSUFFICIENT_RESOURCES;
3238             }
3239
3240             /* Read the value */
3241             RtlInitUnicodeString(&ValueName, RegistryPropertyName);
3242             Status = ZwQueryValueKey(KeyHandle, &ValueName,
3243                 KeyValuePartialInformation, ValueInformation,
3244                 ValueInformationLength,
3245                 &ValueInformationLength);
3246             ZwClose(KeyHandle);
3247
3248             /* Return data */
3249             *ResultLength = ValueInformation->DataLength;
3250
3251             if (!NT_SUCCESS(Status))
3252             {
3253                 ExFreePool(ValueInformation);
3254                 if (Status == STATUS_BUFFER_OVERFLOW)
3255                     return STATUS_BUFFER_TOO_SMALL;
3256                 DPRINT1("Problem: Status=0x%08x, ResultLength = %d\n", Status, *ResultLength);
3257                 return Status;
3258             }
3259
3260             /* FIXME: Verify the value (NULL-terminated, correct format). */
3261             RtlCopyMemory(PropertyBuffer, ValueInformation->Data,
3262                 ValueInformation->DataLength);
3263             ExFreePool(ValueInformation);
3264
3265             return STATUS_SUCCESS;
3266         }
3267
3268     case DevicePropertyBootConfiguration:
3269         Length = 0;
3270         if (DeviceNode->BootResources->Count != 0)
3271         {
3272             Length = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
3273         }
3274         Data = DeviceNode->BootResources;
3275         break;
3276
3277         /* FIXME: use a translated boot configuration instead */
3278     case DevicePropertyBootConfigurationTranslated:
3279         Length = 0;
3280         if (DeviceNode->BootResources->Count != 0)
3281         {
3282             Length = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
3283         }
3284         Data = DeviceNode->BootResources;
3285         break;
3286
3287     case DevicePropertyEnumeratorName:
3288         /* A buffer overflow can't happen here, since InstancePath
3289         * always contains the enumerator name followed by \\ */
3290         Ptr = wcschr(DeviceNode->InstancePath.Buffer, L'\\');
3291         ASSERT(Ptr);
3292         Length = (Ptr - DeviceNode->InstancePath.Buffer) * sizeof(WCHAR);
3293         Data = DeviceNode->InstancePath.Buffer;
3294         break;
3295
3296     case DevicePropertyPhysicalDeviceObjectName:
3297         /* InstancePath buffer is NULL terminated, so we can do this */
3298         Length = DeviceNode->InstancePath.MaximumLength;
3299         Data = DeviceNode->InstancePath.Buffer;
3300         break;
3301
3302     default:
3303         return STATUS_INVALID_PARAMETER_2;
3304     }
3305
3306     /* Prepare returned values */
3307     *ResultLength = Length;
3308     if (BufferLength < Length)
3309         return STATUS_BUFFER_TOO_SMALL;
3310     RtlCopyMemory(PropertyBuffer, Data, Length);
3311
3312     /* NULL terminate the string (if required) */
3313     if (DeviceProperty == DevicePropertyEnumeratorName)
3314         ((LPWSTR)PropertyBuffer)[Length / sizeof(WCHAR)] = UNICODE_NULL;
3315
3316     return STATUS_SUCCESS;
3317 }
3318
3319 /*
3320  * @unimplemented
3321  */
3322 VOID
3323 NTAPI
3324 IoInvalidateDeviceState(IN PDEVICE_OBJECT PhysicalDeviceObject)
3325 {
3326     UNIMPLEMENTED;
3327 }
3328
3329 /**
3330  * @name IoOpenDeviceRegistryKey
3331  *
3332  * Open a registry key unique for a specified driver or device instance.
3333  *
3334  * @param DeviceObject   Device to get the registry key for.
3335  * @param DevInstKeyType Type of the key to return.
3336  * @param DesiredAccess  Access mask (eg. KEY_READ | KEY_WRITE).
3337  * @param DevInstRegKey  Handle to the opened registry key on
3338  *                       successful return.
3339  *
3340  * @return Status.
3341  *
3342  * @implemented
3343  */
3344 NTSTATUS
3345 NTAPI
3346 IoOpenDeviceRegistryKey(IN PDEVICE_OBJECT DeviceObject,
3347                         IN ULONG DevInstKeyType,
3348                         IN ACCESS_MASK DesiredAccess,
3349                         OUT PHANDLE DevInstRegKey)
3350 {
3351    static WCHAR RootKeyName[] =
3352       L"\\Registry\\Machine\\System\\CurrentControlSet\\";
3353    static WCHAR ProfileKeyName[] =
3354       L"Hardware Profiles\\Current\\System\\CurrentControlSet\\";
3355    static WCHAR ClassKeyName[] = L"Control\\Class\\";
3356    static WCHAR EnumKeyName[] = L"Enum\\";
3357    static WCHAR DeviceParametersKeyName[] = L"Device Parameters";
3358    ULONG KeyNameLength;
3359    LPWSTR KeyNameBuffer;
3360    UNICODE_STRING KeyName;
3361    ULONG DriverKeyLength;
3362    OBJECT_ATTRIBUTES ObjectAttributes;
3363    PDEVICE_NODE DeviceNode = NULL;
3364    NTSTATUS Status;
3365
3366    DPRINT("IoOpenDeviceRegistryKey() called\n");
3367
3368    if ((DevInstKeyType & (PLUGPLAY_REGKEY_DEVICE | PLUGPLAY_REGKEY_DRIVER)) == 0)
3369    {
3370        DPRINT1("IoOpenDeviceRegistryKey(): got wrong params, exiting... \n");
3371        return STATUS_INVALID_PARAMETER;
3372    }
3373
3374    /*
3375     * Calculate the length of the base key name. This is the full
3376     * name for driver key or the name excluding "Device Parameters"
3377     * subkey for device key.
3378     */
3379
3380    KeyNameLength = sizeof(RootKeyName);
3381    if (DevInstKeyType & PLUGPLAY_REGKEY_CURRENT_HWPROFILE)
3382       KeyNameLength += sizeof(ProfileKeyName) - sizeof(UNICODE_NULL);
3383    if (DevInstKeyType & PLUGPLAY_REGKEY_DRIVER)
3384    {
3385       KeyNameLength += sizeof(ClassKeyName) - sizeof(UNICODE_NULL);
3386       Status = IoGetDeviceProperty(DeviceObject, DevicePropertyDriverKeyName,
3387                                    0, NULL, &DriverKeyLength);
3388       if (Status != STATUS_BUFFER_TOO_SMALL)
3389          return Status;
3390       KeyNameLength += DriverKeyLength;
3391    }
3392    else
3393    {
3394       DeviceNode = IopGetDeviceNode(DeviceObject);
3395       KeyNameLength += sizeof(EnumKeyName) - sizeof(UNICODE_NULL) +
3396                        DeviceNode->InstancePath.Length;
3397    }
3398
3399    /*
3400     * Now allocate the buffer for the key name...
3401     */
3402
3403    KeyNameBuffer = ExAllocatePool(PagedPool, KeyNameLength);
3404    if (KeyNameBuffer == NULL)
3405       return STATUS_INSUFFICIENT_RESOURCES;
3406
3407    KeyName.Length = 0;
3408    KeyName.MaximumLength = (USHORT)KeyNameLength;
3409    KeyName.Buffer = KeyNameBuffer;
3410
3411    /*
3412     * ...and build the key name.
3413     */
3414
3415    KeyName.Length += sizeof(RootKeyName) - sizeof(UNICODE_NULL);
3416    RtlCopyMemory(KeyNameBuffer, RootKeyName, KeyName.Length);
3417
3418    if (DevInstKeyType & PLUGPLAY_REGKEY_CURRENT_HWPROFILE)
3419       RtlAppendUnicodeToString(&KeyName, ProfileKeyName);
3420
3421    if (DevInstKeyType & PLUGPLAY_REGKEY_DRIVER)
3422    {
3423       RtlAppendUnicodeToString(&KeyName, ClassKeyName);
3424       Status = IoGetDeviceProperty(DeviceObject, DevicePropertyDriverKeyName,
3425                                    DriverKeyLength, KeyNameBuffer +
3426                                    (KeyName.Length / sizeof(WCHAR)),
3427                                    &DriverKeyLength);
3428       if (!NT_SUCCESS(Status))
3429       {
3430          DPRINT1("Call to IoGetDeviceProperty() failed with Status 0x%08lx\n", Status);
3431          ExFreePool(KeyNameBuffer);
3432          return Status;
3433       }
3434       KeyName.Length += (USHORT)DriverKeyLength - sizeof(UNICODE_NULL);
3435    }
3436    else
3437    {
3438       RtlAppendUnicodeToString(&KeyName, EnumKeyName);
3439       Status = RtlAppendUnicodeStringToString(&KeyName, &DeviceNode->InstancePath);
3440       if (DeviceNode->InstancePath.Length == 0)
3441       {
3442          ExFreePool(KeyNameBuffer);
3443          return Status;
3444       }
3445    }
3446
3447    /*
3448     * Open the base key.
3449     */
3450    Status = IopOpenRegistryKeyEx(DevInstRegKey, NULL, &KeyName, DesiredAccess);
3451    if (!NT_SUCCESS(Status))
3452    {
3453       DPRINT1("IoOpenDeviceRegistryKey(%wZ): Base key doesn't exist, exiting... (Status 0x%08lx)\n", &KeyName, Status);
3454       ExFreePool(KeyNameBuffer);
3455       return Status;
3456    }
3457    ExFreePool(KeyNameBuffer);
3458
3459    /*
3460     * For driver key we're done now.
3461     */
3462
3463    if (DevInstKeyType & PLUGPLAY_REGKEY_DRIVER)
3464       return Status;
3465
3466    /*
3467     * Let's go further. For device key we must open "Device Parameters"
3468     * subkey and create it if it doesn't exist yet.
3469     */
3470
3471    RtlInitUnicodeString(&KeyName, DeviceParametersKeyName);
3472    InitializeObjectAttributes(&ObjectAttributes, &KeyName,
3473                               OBJ_CASE_INSENSITIVE, *DevInstRegKey, NULL);
3474    Status = ZwCreateKey(DevInstRegKey, DesiredAccess, &ObjectAttributes,
3475                         0, NULL, REG_OPTION_NON_VOLATILE, NULL);
3476    ZwClose(ObjectAttributes.RootDirectory);
3477
3478    return Status;
3479 }
3480
3481 /*
3482  * @unimplemented
3483  */
3484 VOID
3485 NTAPI
3486 IoRequestDeviceEject(IN PDEVICE_OBJECT PhysicalDeviceObject)
3487 {
3488    UNIMPLEMENTED;
3489 }
3490
3491 /*
3492  * @implemented
3493  */
3494 VOID
3495 NTAPI
3496 IoInvalidateDeviceRelations(
3497     IN PDEVICE_OBJECT DeviceObject,
3498     IN DEVICE_RELATION_TYPE Type)
3499 {
3500     PIO_WORKITEM WorkItem;
3501     PINVALIDATE_DEVICE_RELATION_DATA Data;
3502
3503     Data = ExAllocatePool(PagedPool, sizeof(INVALIDATE_DEVICE_RELATION_DATA));
3504     if (!Data)
3505         return;
3506     WorkItem = IoAllocateWorkItem(DeviceObject);
3507     if (!WorkItem)
3508     {
3509         ExFreePool(Data);
3510         return;
3511     }
3512
3513     ObReferenceObject(DeviceObject);
3514     Data->DeviceObject = DeviceObject;
3515     Data->Type = Type;
3516     Data->WorkItem = WorkItem;
3517
3518     IoQueueWorkItem(
3519         WorkItem,
3520         IopAsynchronousInvalidateDeviceRelations,
3521         DelayedWorkQueue,
3522         Data);
3523 }
3524
3525 /*
3526  * @implemented
3527  */
3528 NTSTATUS
3529 NTAPI
3530 IoSynchronousInvalidateDeviceRelations(
3531     IN PDEVICE_OBJECT DeviceObject,
3532     IN DEVICE_RELATION_TYPE Type)
3533 {
3534     PAGED_CODE();
3535
3536     switch (Type)
3537     {
3538         case BusRelations:
3539             /* Enumerate the device */
3540             return IopEnumerateDevice(DeviceObject);
3541         case PowerRelations:
3542              /* Not handled yet */
3543              return STATUS_NOT_IMPLEMENTED;
3544         case TargetDeviceRelation:
3545             /* Nothing to do */
3546             return STATUS_SUCCESS;
3547         default:
3548             /* Ejection relations are not supported */
3549             return STATUS_NOT_SUPPORTED;
3550     }
3551 }
3552
3553 /*
3554  * @unimplemented
3555  */
3556 BOOLEAN
3557 NTAPI
3558 IoTranslateBusAddress(IN INTERFACE_TYPE InterfaceType,
3559                       IN ULONG BusNumber,
3560                       IN PHYSICAL_ADDRESS BusAddress,
3561                       IN OUT PULONG AddressSpace,
3562                       OUT PPHYSICAL_ADDRESS TranslatedAddress)
3563 {
3564     UNIMPLEMENTED;
3565     return FALSE;
3566 }