[NTOSKRNL] Fix the indentation of some pnp manager functions.
authorEric Kohl <eric.kohl@reactos.org>
Fri, 21 Sep 2018 13:08:43 +0000 (15:08 +0200)
committerEric Kohl <eric.kohl@reactos.org>
Fri, 21 Sep 2018 13:08:43 +0000 (15:08 +0200)
ntoskrnl/io/pnpmgr/pnpmgr.c

index e4cb7db..e0e040a 100644 (file)
@@ -435,68 +435,68 @@ FASTCALL
 IopInitializeDevice(PDEVICE_NODE DeviceNode,
                     PDRIVER_OBJECT DriverObject)
 {
-   PDEVICE_OBJECT Fdo;
-   NTSTATUS Status;
+    PDEVICE_OBJECT Fdo;
+    NTSTATUS Status;
 
-   if (!DriverObject)
-   {
-      /* Special case for bus driven devices */
-      DeviceNode->Flags |= DNF_ADDED;
-      return STATUS_SUCCESS;
-   }
+    if (!DriverObject)
+    {
+        /* Special case for bus driven devices */
+        DeviceNode->Flags |= DNF_ADDED;
+        return STATUS_SUCCESS;
+    }
 
-   if (!DriverObject->DriverExtension->AddDevice)
-   {
-      DeviceNode->Flags |= DNF_LEGACY_DRIVER;
-   }
+    if (!DriverObject->DriverExtension->AddDevice)
+    {
+        DeviceNode->Flags |= DNF_LEGACY_DRIVER;
+    }
 
-   if (DeviceNode->Flags & DNF_LEGACY_DRIVER)
-   {
-      DeviceNode->Flags |= (DNF_ADDED | DNF_STARTED);
-      return STATUS_SUCCESS;
-   }
+    if (DeviceNode->Flags & DNF_LEGACY_DRIVER)
+    {
+        DeviceNode->Flags |= (DNF_ADDED | DNF_STARTED);
+        return STATUS_SUCCESS;
+    }
 
-   /* This is a Plug and Play driver */
-   DPRINT("Plug and Play driver found\n");
-   ASSERT(DeviceNode->PhysicalDeviceObject);
+    /* This is a Plug and Play driver */
+    DPRINT("Plug and Play driver found\n");
+    ASSERT(DeviceNode->PhysicalDeviceObject);
 
-   DPRINT("Calling %wZ->AddDevice(%wZ)\n",
-      &DriverObject->DriverName,
-      &DeviceNode->InstancePath);
-   Status = DriverObject->DriverExtension->AddDevice(
-      DriverObject, DeviceNode->PhysicalDeviceObject);
-   if (!NT_SUCCESS(Status))
-   {
-      DPRINT1("%wZ->AddDevice(%wZ) failed with status 0x%x\n",
-              &DriverObject->DriverName,
-              &DeviceNode->InstancePath,
-              Status);
-      IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
-      DeviceNode->Problem = CM_PROB_FAILED_ADD;
-      return Status;
-   }
+    DPRINT("Calling %wZ->AddDevice(%wZ)\n",
+           &DriverObject->DriverName,
+           &DeviceNode->InstancePath);
+    Status = DriverObject->DriverExtension->AddDevice(DriverObject,
+                                                      DeviceNode->PhysicalDeviceObject);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("%wZ->AddDevice(%wZ) failed with status 0x%x\n",
+                &DriverObject->DriverName,
+                &DeviceNode->InstancePath,
+                Status);
+        IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
+        DeviceNode->Problem = CM_PROB_FAILED_ADD;
+        return Status;
+    }
 
-   Fdo = IoGetAttachedDeviceReference(DeviceNode->PhysicalDeviceObject);
+    Fdo = IoGetAttachedDeviceReference(DeviceNode->PhysicalDeviceObject);
 
-   /* Check if we have a ACPI device (needed for power management) */
-   if (Fdo->DeviceType == FILE_DEVICE_ACPI)
-   {
-      static BOOLEAN SystemPowerDeviceNodeCreated = FALSE;
+    /* Check if we have a ACPI device (needed for power management) */
+    if (Fdo->DeviceType == FILE_DEVICE_ACPI)
+    {
+        static BOOLEAN SystemPowerDeviceNodeCreated = FALSE;
 
-      /* There can be only one system power device */
-      if (!SystemPowerDeviceNodeCreated)
-      {
-         PopSystemPowerDeviceNode = DeviceNode;
-         ObReferenceObject(PopSystemPowerDeviceNode->PhysicalDeviceObject);
-         SystemPowerDeviceNodeCreated = TRUE;
-      }
-   }
+        /* There can be only one system power device */
+        if (!SystemPowerDeviceNodeCreated)
+        {
+            PopSystemPowerDeviceNode = DeviceNode;
+            ObReferenceObject(PopSystemPowerDeviceNode->PhysicalDeviceObject);
+            SystemPowerDeviceNodeCreated = TRUE;
+        }
+    }
 
-   ObDereferenceObject(Fdo);
+    ObDereferenceObject(Fdo);
 
-   IopDeviceNodeSetFlag(DeviceNode, DNF_ADDED);
+    IopDeviceNodeSetFlag(DeviceNode, DNF_ADDED);
 
-   return STATUS_SUCCESS;
+    return STATUS_SUCCESS;
 }
 
 static
@@ -762,59 +762,59 @@ NTSTATUS
 IopStopDevice(
    PDEVICE_NODE DeviceNode)
 {
-   NTSTATUS Status;
+    NTSTATUS Status;
 
-   DPRINT("Stopping device: %wZ\n", &DeviceNode->InstancePath);
+    DPRINT("Stopping device: %wZ\n", &DeviceNode->InstancePath);
 
-   Status = IopQueryStopDevice(DeviceNode->PhysicalDeviceObject);
-   if (NT_SUCCESS(Status))
-   {
-       IopSendStopDevice(DeviceNode->PhysicalDeviceObject);
+    Status = IopQueryStopDevice(DeviceNode->PhysicalDeviceObject);
+    if (NT_SUCCESS(Status))
+    {
+        IopSendStopDevice(DeviceNode->PhysicalDeviceObject);
 
-       DeviceNode->Flags &= ~(DNF_STARTED | DNF_START_REQUEST_PENDING);
-       DeviceNode->Flags |= DNF_STOPPED;
+        DeviceNode->Flags &= ~(DNF_STARTED | DNF_START_REQUEST_PENDING);
+        DeviceNode->Flags |= DNF_STOPPED;
 
-       return STATUS_SUCCESS;
-   }
+        return STATUS_SUCCESS;
+    }
 
-   return Status;
+    return Status;
 }
 
 NTSTATUS
 IopStartDevice(
    PDEVICE_NODE DeviceNode)
 {
-   NTSTATUS Status;
-   HANDLE InstanceHandle = NULL, ControlHandle = NULL;
-   UNICODE_STRING KeyName, ValueString;
-   OBJECT_ATTRIBUTES ObjectAttributes;
+    NTSTATUS Status;
+    HANDLE InstanceHandle = NULL, ControlHandle = NULL;
+    UNICODE_STRING KeyName, ValueString;
+    OBJECT_ATTRIBUTES ObjectAttributes;
 
-   if (DeviceNode->Flags & DNF_DISABLED)
-       return STATUS_SUCCESS;
+    if (DeviceNode->Flags & DNF_DISABLED)
+        return STATUS_SUCCESS;
 
-   Status = IopAssignDeviceResources(DeviceNode);
-   if (!NT_SUCCESS(Status))
-       goto ByeBye;
+    Status = IopAssignDeviceResources(DeviceNode);
+    if (!NT_SUCCESS(Status))
+        goto ByeBye;
 
-   /* New PnP ABI */
-   IopStartAndEnumerateDevice(DeviceNode);
+    /* New PnP ABI */
+    IopStartAndEnumerateDevice(DeviceNode);
 
-   /* FIX: Should be done in new device instance code */
-   Status = IopCreateDeviceKeyPath(&DeviceNode->InstancePath, REG_OPTION_NON_VOLATILE, &InstanceHandle);
-   if (!NT_SUCCESS(Status))
-       goto ByeBye;
+    /* FIX: Should be done in new device instance code */
+    Status = IopCreateDeviceKeyPath(&DeviceNode->InstancePath, REG_OPTION_NON_VOLATILE, &InstanceHandle);
+    if (!NT_SUCCESS(Status))
+        goto ByeBye;
 
-   /* FIX: Should be done in IoXxxPrepareDriverLoading */
-   // {
-   RtlInitUnicodeString(&KeyName, L"Control");
-   InitializeObjectAttributes(&ObjectAttributes,
-                              &KeyName,
-                              OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
-                              InstanceHandle,
-                              NULL);
-   Status = ZwCreateKey(&ControlHandle, KEY_SET_VALUE, &ObjectAttributes, 0, NULL, REG_OPTION_VOLATILE, NULL);
-   if (!NT_SUCCESS(Status))
-       goto ByeBye;
+    /* FIX: Should be done in IoXxxPrepareDriverLoading */
+    // {
+    RtlInitUnicodeString(&KeyName, L"Control");
+    InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
+                               InstanceHandle,
+                               NULL);
+    Status = ZwCreateKey(&ControlHandle, KEY_SET_VALUE, &ObjectAttributes, 0, NULL, REG_OPTION_VOLATILE, NULL);
+    if (!NT_SUCCESS(Status))
+        goto ByeBye;
 
    RtlInitUnicodeString(&KeyName, L"ActiveService");
    ValueString = DeviceNode->ServiceName;
@@ -824,13 +824,13 @@ IopStartDevice(
    // }
 
 ByeBye:
-   if (ControlHandle != NULL)
-       ZwClose(ControlHandle);
+    if (ControlHandle != NULL)
+        ZwClose(ControlHandle);
 
-   if (InstanceHandle != NULL)
-       ZwClose(InstanceHandle);
+    if (InstanceHandle != NULL)
+        ZwClose(InstanceHandle);
 
-   return Status;
+    return Status;
 }
 
 NTSTATUS
@@ -838,72 +838,72 @@ NTAPI
 IopQueryDeviceCapabilities(PDEVICE_NODE DeviceNode,
                            PDEVICE_CAPABILITIES DeviceCaps)
 {
-   IO_STATUS_BLOCK StatusBlock;
-   IO_STACK_LOCATION Stack;
-   NTSTATUS Status;
-   HANDLE InstanceKey;
-   UNICODE_STRING ValueName;
-
-   /* Set up the Header */
-   RtlZeroMemory(DeviceCaps, sizeof(DEVICE_CAPABILITIES));
-   DeviceCaps->Size = sizeof(DEVICE_CAPABILITIES);
-   DeviceCaps->Version = 1;
-   DeviceCaps->Address = -1;
-   DeviceCaps->UINumber = -1;
-
-   /* Set up the Stack */
-   RtlZeroMemory(&Stack, sizeof(IO_STACK_LOCATION));
-   Stack.Parameters.DeviceCapabilities.Capabilities = DeviceCaps;
-
-   /* Send the IRP */
-   Status = IopInitiatePnpIrp(DeviceNode->PhysicalDeviceObject,
-                              &StatusBlock,
-                              IRP_MN_QUERY_CAPABILITIES,
-                              &Stack);
-   if (!NT_SUCCESS(Status))
-   {
-       if (Status != STATUS_NOT_SUPPORTED)
-       {
-          DPRINT1("IRP_MN_QUERY_CAPABILITIES failed with status 0x%lx\n", Status);
-       }
-       return Status;
-   }
+    IO_STATUS_BLOCK StatusBlock;
+    IO_STACK_LOCATION Stack;
+    NTSTATUS Status;
+    HANDLE InstanceKey;
+    UNICODE_STRING ValueName;
 
-   DeviceNode->CapabilityFlags = *(PULONG)((ULONG_PTR)&DeviceCaps->Version + sizeof(DeviceCaps->Version));
+    /* Set up the Header */
+    RtlZeroMemory(DeviceCaps, sizeof(DEVICE_CAPABILITIES));
+    DeviceCaps->Size = sizeof(DEVICE_CAPABILITIES);
+    DeviceCaps->Version = 1;
+    DeviceCaps->Address = -1;
+    DeviceCaps->UINumber = -1;
 
-   if (DeviceCaps->NoDisplayInUI)
-       DeviceNode->UserFlags |= DNUF_DONT_SHOW_IN_UI;
-   else
-       DeviceNode->UserFlags &= ~DNUF_DONT_SHOW_IN_UI;
+    /* Set up the Stack */
+    RtlZeroMemory(&Stack, sizeof(IO_STACK_LOCATION));
+    Stack.Parameters.DeviceCapabilities.Capabilities = DeviceCaps;
 
-   Status = IopCreateDeviceKeyPath(&DeviceNode->InstancePath, REG_OPTION_NON_VOLATILE, &InstanceKey);
-   if (NT_SUCCESS(Status))
-   {
-      /* Set 'Capabilities' value */
-      RtlInitUnicodeString(&ValueName, L"Capabilities");
-      Status = ZwSetValueKey(InstanceKey,
-                             &ValueName,
-                             0,
-                             REG_DWORD,
-                             &DeviceNode->CapabilityFlags,
-                             sizeof(ULONG));
+    /* Send the IRP */
+    Status = IopInitiatePnpIrp(DeviceNode->PhysicalDeviceObject,
+                               &StatusBlock,
+                               IRP_MN_QUERY_CAPABILITIES,
+                               &Stack);
+    if (!NT_SUCCESS(Status))
+    {
+        if (Status != STATUS_NOT_SUPPORTED)
+        {
+            DPRINT1("IRP_MN_QUERY_CAPABILITIES failed with status 0x%lx\n", Status);
+        }
+        return Status;
+    }
 
-      /* Set 'UINumber' value */
-      if (DeviceCaps->UINumber != MAXULONG)
-      {
-         RtlInitUnicodeString(&ValueName, L"UINumber");
-         Status = ZwSetValueKey(InstanceKey,
-                                &ValueName,
-                                0,
-                                REG_DWORD,
-                                &DeviceCaps->UINumber,
-                                sizeof(ULONG));
-      }
+    DeviceNode->CapabilityFlags = *(PULONG)((ULONG_PTR)&DeviceCaps->Version + sizeof(DeviceCaps->Version));
 
-      ZwClose(InstanceKey);
-   }
+    if (DeviceCaps->NoDisplayInUI)
+        DeviceNode->UserFlags |= DNUF_DONT_SHOW_IN_UI;
+    else
+        DeviceNode->UserFlags &= ~DNUF_DONT_SHOW_IN_UI;
 
-   return Status;
+    Status = IopCreateDeviceKeyPath(&DeviceNode->InstancePath, REG_OPTION_NON_VOLATILE, &InstanceKey);
+    if (NT_SUCCESS(Status))
+    {
+        /* Set 'Capabilities' value */
+        RtlInitUnicodeString(&ValueName, L"Capabilities");
+        Status = ZwSetValueKey(InstanceKey,
+                               &ValueName,
+                               0,
+                               REG_DWORD,
+                               &DeviceNode->CapabilityFlags,
+                               sizeof(ULONG));
+
+        /* Set 'UINumber' value */
+        if (DeviceCaps->UINumber != MAXULONG)
+        {
+            RtlInitUnicodeString(&ValueName, L"UINumber");
+            Status = ZwSetValueKey(InstanceKey,
+                                   &ValueName,
+                                   0,
+                                   REG_DWORD,
+                                   &DeviceCaps->UINumber,
+                                   sizeof(ULONG));
+        }
+
+        ZwClose(InstanceKey);
+    }
+
+    return Status;
 }
 
 static
@@ -939,85 +939,86 @@ IopDeviceActionWorker(
 NTSTATUS
 IopGetSystemPowerDeviceObject(PDEVICE_OBJECT *DeviceObject)
 {
-   KIRQL OldIrql;
+    KIRQL OldIrql;
 
-   if (PopSystemPowerDeviceNode)
-   {
-      KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
-      *DeviceObject = PopSystemPowerDeviceNode->PhysicalDeviceObject;
-      KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
+    if (PopSystemPowerDeviceNode)
+    {
+        KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
+        *DeviceObject = PopSystemPowerDeviceNode->PhysicalDeviceObject;
+        KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
 
-      return STATUS_SUCCESS;
-   }
+        return STATUS_SUCCESS;
+    }
 
-   return STATUS_UNSUCCESSFUL;
+    return STATUS_UNSUCCESSFUL;
 }
 
 USHORT
 NTAPI
 IopGetBusTypeGuidIndex(LPGUID BusTypeGuid)
 {
-   USHORT i = 0, FoundIndex = 0xFFFF;
-   ULONG NewSize;
-   PVOID NewList;
+    USHORT i = 0, FoundIndex = 0xFFFF;
+    ULONG NewSize;
+    PVOID NewList;
 
-   /* Acquire the lock */
-   ExAcquireFastMutex(&PnpBusTypeGuidList->Lock);
+    /* Acquire the lock */
+    ExAcquireFastMutex(&PnpBusTypeGuidList->Lock);
 
-   /* Loop all entries */
-   while (i < PnpBusTypeGuidList->GuidCount)
-   {
-       /* Try to find a match */
-       if (RtlCompareMemory(BusTypeGuid,
-                            &PnpBusTypeGuidList->Guids[i],
-                            sizeof(GUID)) == sizeof(GUID))
-       {
-           /* Found it */
-           FoundIndex = i;
-           goto Quickie;
-       }
-       i++;
-   }
+    /* Loop all entries */
+    while (i < PnpBusTypeGuidList->GuidCount)
+    {
+         /* Try to find a match */
+         if (RtlCompareMemory(BusTypeGuid,
+                              &PnpBusTypeGuidList->Guids[i],
+                              sizeof(GUID)) == sizeof(GUID))
+         {
+              /* Found it */
+              FoundIndex = i;
+              goto Quickie;
+         }
+         i++;
+    }
 
-   /* Check if we have to grow the list */
-   if (PnpBusTypeGuidList->GuidCount)
-   {
-       /* Calculate the new size */
-       NewSize = sizeof(IO_BUS_TYPE_GUID_LIST) +
-                (sizeof(GUID) * PnpBusTypeGuidList->GuidCount);
+    /* Check if we have to grow the list */
+    if (PnpBusTypeGuidList->GuidCount)
+    {
+        /* Calculate the new size */
+        NewSize = sizeof(IO_BUS_TYPE_GUID_LIST) +
+                 (sizeof(GUID) * PnpBusTypeGuidList->GuidCount);
 
-       /* Allocate the new copy */
-       NewList = ExAllocatePool(PagedPool, NewSize);
+        /* Allocate the new copy */
+        NewList = ExAllocatePool(PagedPool, NewSize);
 
-       if (!NewList) {
-       /* Fail */
-       ExFreePool(PnpBusTypeGuidList);
-       goto Quickie;
-       }
+        if (!NewList)
+        {
+            /* Fail */
+            ExFreePool(PnpBusTypeGuidList);
+            goto Quickie;
+        }
 
-       /* Now copy them, decrease the size too */
-       NewSize -= sizeof(GUID);
-       RtlCopyMemory(NewList, PnpBusTypeGuidList, NewSize);
+        /* Now copy them, decrease the size too */
+        NewSize -= sizeof(GUID);
+        RtlCopyMemory(NewList, PnpBusTypeGuidList, NewSize);
 
-       /* Free the old list */
-       ExFreePool(PnpBusTypeGuidList);
+        /* Free the old list */
+        ExFreePool(PnpBusTypeGuidList);
 
-       /* Use the new buffer */
-       PnpBusTypeGuidList = NewList;
-   }
+        /* Use the new buffer */
+        PnpBusTypeGuidList = NewList;
+    }
 
-   /* Copy the new GUID */
-   RtlCopyMemory(&PnpBusTypeGuidList->Guids[PnpBusTypeGuidList->GuidCount],
-                 BusTypeGuid,
-                 sizeof(GUID));
+    /* Copy the new GUID */
+    RtlCopyMemory(&PnpBusTypeGuidList->Guids[PnpBusTypeGuidList->GuidCount],
+                  BusTypeGuid,
+                  sizeof(GUID));
 
-   /* The new entry is the index */
-   FoundIndex = (USHORT)PnpBusTypeGuidList->GuidCount;
-   PnpBusTypeGuidList->GuidCount++;
+    /* The new entry is the index */
+    FoundIndex = (USHORT)PnpBusTypeGuidList->GuidCount;
+    PnpBusTypeGuidList->GuidCount++;
 
 Quickie:
-   ExReleaseFastMutex(&PnpBusTypeGuidList->Lock);
-   return FoundIndex;
+    ExReleaseFastMutex(&PnpBusTypeGuidList->Lock);
+    return FoundIndex;
 }
 
 /*
@@ -1040,136 +1041,136 @@ IopCreateDeviceNode(PDEVICE_NODE ParentNode,
                     PUNICODE_STRING ServiceName,
                     PDEVICE_NODE *DeviceNode)
 {
-   PDEVICE_NODE Node;
-   NTSTATUS Status;
-   KIRQL OldIrql;
-   UNICODE_STRING FullServiceName;
-   UNICODE_STRING LegacyPrefix = RTL_CONSTANT_STRING(L"LEGACY_");
-   UNICODE_STRING UnknownDeviceName = RTL_CONSTANT_STRING(L"UNKNOWN");
-   UNICODE_STRING KeyName, ClassName;
-   PUNICODE_STRING ServiceName1;
-   ULONG LegacyValue;
-   UNICODE_STRING ClassGUID;
-   HANDLE InstanceHandle;
-
-   DPRINT("ParentNode 0x%p PhysicalDeviceObject 0x%p ServiceName %wZ\n",
-      ParentNode, PhysicalDeviceObject, ServiceName);
-
-   Node = ExAllocatePoolWithTag(NonPagedPool, sizeof(DEVICE_NODE), TAG_IO_DEVNODE);
-   if (!Node)
-   {
-      return STATUS_INSUFFICIENT_RESOURCES;
-   }
+    PDEVICE_NODE Node;
+    NTSTATUS Status;
+    KIRQL OldIrql;
+    UNICODE_STRING FullServiceName;
+    UNICODE_STRING LegacyPrefix = RTL_CONSTANT_STRING(L"LEGACY_");
+    UNICODE_STRING UnknownDeviceName = RTL_CONSTANT_STRING(L"UNKNOWN");
+    UNICODE_STRING KeyName, ClassName;
+    PUNICODE_STRING ServiceName1;
+    ULONG LegacyValue;
+    UNICODE_STRING ClassGUID;
+    HANDLE InstanceHandle;
+
+    DPRINT("ParentNode 0x%p PhysicalDeviceObject 0x%p ServiceName %wZ\n",
+           ParentNode, PhysicalDeviceObject, ServiceName);
+
+    Node = ExAllocatePoolWithTag(NonPagedPool, sizeof(DEVICE_NODE), TAG_IO_DEVNODE);
+    if (!Node)
+    {
+        return STATUS_INSUFFICIENT_RESOURCES;
+    }
 
-   RtlZeroMemory(Node, sizeof(DEVICE_NODE));
+    RtlZeroMemory(Node, sizeof(DEVICE_NODE));
 
-   if (!ServiceName)
-       ServiceName1 = &UnknownDeviceName;
-   else
-       ServiceName1 = ServiceName;
+    if (!ServiceName)
+        ServiceName1 = &UnknownDeviceName;
+    else
+        ServiceName1 = ServiceName;
 
-   if (!PhysicalDeviceObject)
-   {
-      FullServiceName.MaximumLength = LegacyPrefix.Length + ServiceName1->Length + sizeof(UNICODE_NULL);
-      FullServiceName.Length = 0;
-      FullServiceName.Buffer = ExAllocatePool(PagedPool, FullServiceName.MaximumLength);
-      if (!FullServiceName.Buffer)
-      {
-          ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
-          return STATUS_INSUFFICIENT_RESOURCES;
-      }
+    if (!PhysicalDeviceObject)
+    {
+        FullServiceName.MaximumLength = LegacyPrefix.Length + ServiceName1->Length + sizeof(UNICODE_NULL);
+        FullServiceName.Length = 0;
+        FullServiceName.Buffer = ExAllocatePool(PagedPool, FullServiceName.MaximumLength);
+        if (!FullServiceName.Buffer)
+        {
+            ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
+            return STATUS_INSUFFICIENT_RESOURCES;
+        }
 
-      RtlAppendUnicodeStringToString(&FullServiceName, &LegacyPrefix);
-      RtlAppendUnicodeStringToString(&FullServiceName, ServiceName1);
-      RtlUpcaseUnicodeString(&FullServiceName, &FullServiceName, FALSE);
+        RtlAppendUnicodeStringToString(&FullServiceName, &LegacyPrefix);
+        RtlAppendUnicodeStringToString(&FullServiceName, ServiceName1);
+        RtlUpcaseUnicodeString(&FullServiceName, &FullServiceName, FALSE);
 
-      Status = PnpRootCreateDevice(&FullServiceName, NULL, &PhysicalDeviceObject, &Node->InstancePath);
-      if (!NT_SUCCESS(Status))
-      {
-         DPRINT1("PnpRootCreateDevice() failed with status 0x%08X\n", Status);
-         ExFreePool(FullServiceName.Buffer);
-         ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
-         return Status;
-      }
+        Status = PnpRootCreateDevice(&FullServiceName, NULL, &PhysicalDeviceObject, &Node->InstancePath);
+        if (!NT_SUCCESS(Status))
+        {
+            DPRINT1("PnpRootCreateDevice() failed with status 0x%08X\n", Status);
+            ExFreePool(FullServiceName.Buffer);
+            ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
+            return Status;
+        }
 
-      /* Create the device key for legacy drivers */
-      Status = IopCreateDeviceKeyPath(&Node->InstancePath, REG_OPTION_VOLATILE, &InstanceHandle);
-      if (!NT_SUCCESS(Status))
-      {
-          ExFreePool(FullServiceName.Buffer);
-          ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
-          return Status;
-      }
+        /* Create the device key for legacy drivers */
+        Status = IopCreateDeviceKeyPath(&Node->InstancePath, REG_OPTION_VOLATILE, &InstanceHandle);
+        if (!NT_SUCCESS(Status))
+        {
+            ExFreePool(FullServiceName.Buffer);
+            ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
+            return Status;
+        }
 
-      Node->ServiceName.MaximumLength = ServiceName1->Length + sizeof(UNICODE_NULL);
-      Node->ServiceName.Length = 0;
-      Node->ServiceName.Buffer = ExAllocatePool(PagedPool, Node->ServiceName.MaximumLength);
-      if (!Node->ServiceName.Buffer)
-      {
-          ZwClose(InstanceHandle);
-          ExFreePool(FullServiceName.Buffer);
-          ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
-          return Status;
-      }
+        Node->ServiceName.MaximumLength = ServiceName1->Length + sizeof(UNICODE_NULL);
+        Node->ServiceName.Length = 0;
+        Node->ServiceName.Buffer = ExAllocatePool(PagedPool, Node->ServiceName.MaximumLength);
+        if (!Node->ServiceName.Buffer)
+        {
+            ZwClose(InstanceHandle);
+            ExFreePool(FullServiceName.Buffer);
+            ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
+            return Status;
+        }
 
-      RtlCopyUnicodeString(&Node->ServiceName, ServiceName1);
+        RtlCopyUnicodeString(&Node->ServiceName, ServiceName1);
 
-      if (ServiceName)
-      {
-          RtlInitUnicodeString(&KeyName, L"Service");
-          Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_SZ, ServiceName->Buffer, ServiceName->Length + sizeof(UNICODE_NULL));
-      }
+        if (ServiceName)
+        {
+            RtlInitUnicodeString(&KeyName, L"Service");
+            Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_SZ, ServiceName->Buffer, ServiceName->Length + sizeof(UNICODE_NULL));
+        }
 
-      if (NT_SUCCESS(Status))
-      {
-          RtlInitUnicodeString(&KeyName, L"Legacy");
-          LegacyValue = 1;
-          Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_DWORD, &LegacyValue, sizeof(LegacyValue));
+        if (NT_SUCCESS(Status))
+        {
+            RtlInitUnicodeString(&KeyName, L"Legacy");
+            LegacyValue = 1;
+            Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_DWORD, &LegacyValue, sizeof(LegacyValue));
 
-          RtlInitUnicodeString(&KeyName, L"ConfigFlags");
-          LegacyValue = 0;
-          ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_DWORD, &LegacyValue, sizeof(LegacyValue));
+            RtlInitUnicodeString(&KeyName, L"ConfigFlags");
+            LegacyValue = 0;
+            ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_DWORD, &LegacyValue, sizeof(LegacyValue));
 
-          if (NT_SUCCESS(Status))
-          {
-              RtlInitUnicodeString(&KeyName, L"Class");
-              RtlInitUnicodeString(&ClassName, L"LegacyDriver");
-              Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_SZ, ClassName.Buffer, ClassName.Length + sizeof(UNICODE_NULL));
-              if (NT_SUCCESS(Status))
-              {
-                  RtlInitUnicodeString(&KeyName, L"ClassGUID");
-                  RtlInitUnicodeString(&ClassGUID, L"{8ECC055D-047F-11D1-A537-0000F8753ED1}");
-                  Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_SZ, ClassGUID.Buffer, ClassGUID.Length + sizeof(UNICODE_NULL));
-                  if (NT_SUCCESS(Status))
-                  {
-                      // FIXME: Retrieve the real "description" by looking at the "DisplayName" string
-                      // of the corresponding CurrentControlSet\Services\xxx entry for this driver.
-                      RtlInitUnicodeString(&KeyName, L"DeviceDesc");
-                      Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_SZ, ServiceName1->Buffer, ServiceName1->Length + sizeof(UNICODE_NULL));
-                  }
-              }
-          }
-      }
+            if (NT_SUCCESS(Status))
+            {
+                RtlInitUnicodeString(&KeyName, L"Class");
+                RtlInitUnicodeString(&ClassName, L"LegacyDriver");
+                Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_SZ, ClassName.Buffer, ClassName.Length + sizeof(UNICODE_NULL));
+                if (NT_SUCCESS(Status))
+                {
+                    RtlInitUnicodeString(&KeyName, L"ClassGUID");
+                    RtlInitUnicodeString(&ClassGUID, L"{8ECC055D-047F-11D1-A537-0000F8753ED1}");
+                    Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_SZ, ClassGUID.Buffer, ClassGUID.Length + sizeof(UNICODE_NULL));
+                    if (NT_SUCCESS(Status))
+                    {
+                        // FIXME: Retrieve the real "description" by looking at the "DisplayName" string
+                        // of the corresponding CurrentControlSet\Services\xxx entry for this driver.
+                        RtlInitUnicodeString(&KeyName, L"DeviceDesc");
+                        Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_SZ, ServiceName1->Buffer, ServiceName1->Length + sizeof(UNICODE_NULL));
+                    }
+                }
+            }
+        }
 
-      ZwClose(InstanceHandle);
-      ExFreePool(FullServiceName.Buffer);
+        ZwClose(InstanceHandle);
+        ExFreePool(FullServiceName.Buffer);
 
-      if (!NT_SUCCESS(Status))
-      {
-          ExFreePool(Node->ServiceName.Buffer);
-          ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
-          return Status;
-      }
+        if (!NT_SUCCESS(Status))
+        {
+            ExFreePool(Node->ServiceName.Buffer);
+            ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
+            return Status;
+        }
 
-      IopDeviceNodeSetFlag(Node, DNF_LEGACY_DRIVER);
-      IopDeviceNodeSetFlag(Node, DNF_PROCESSED);
-      IopDeviceNodeSetFlag(Node, DNF_ADDED);
-      IopDeviceNodeSetFlag(Node, DNF_STARTED);
-   }
+        IopDeviceNodeSetFlag(Node, DNF_LEGACY_DRIVER);
+        IopDeviceNodeSetFlag(Node, DNF_PROCESSED);
+        IopDeviceNodeSetFlag(Node, DNF_ADDED);
+        IopDeviceNodeSetFlag(Node, DNF_STARTED);
+    }
 
-   Node->PhysicalDeviceObject = PhysicalDeviceObject;
+    Node->PhysicalDeviceObject = PhysicalDeviceObject;
 
-   ((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode = Node;
+    ((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode = Node;
 
     if (ParentNode)
     {
@@ -1192,22 +1193,22 @@ IopCreateDeviceNode(PDEVICE_NODE ParentNode,
 
     PhysicalDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 
-   *DeviceNode = Node;
+    *DeviceNode = Node;
 
-   return STATUS_SUCCESS;
+    return STATUS_SUCCESS;
 }
 
 NTSTATUS
 IopFreeDeviceNode(PDEVICE_NODE DeviceNode)
 {
-   KIRQL OldIrql;
-   PDEVICE_NODE PrevSibling = NULL;
+    KIRQL OldIrql;
+    PDEVICE_NODE PrevSibling = NULL;
 
-   /* All children must be deleted before a parent is deleted */
-   ASSERT(!DeviceNode->Child);
-   ASSERT(DeviceNode->PhysicalDeviceObject);
+    /* All children must be deleted before a parent is deleted */
+    ASSERT(!DeviceNode->Child);
+    ASSERT(DeviceNode->PhysicalDeviceObject);
 
-   KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
+    KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
 
     /* Get previous sibling */
     if (DeviceNode->Parent && DeviceNode->Parent->Child != DeviceNode)
@@ -1234,36 +1235,36 @@ IopFreeDeviceNode(PDEVICE_NODE DeviceNode)
     if (PrevSibling)
         PrevSibling->Sibling = DeviceNode->Sibling;
 
-   KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
+    KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
 
-   RtlFreeUnicodeString(&DeviceNode->InstancePath);
+    RtlFreeUnicodeString(&DeviceNode->InstancePath);
 
-   RtlFreeUnicodeString(&DeviceNode->ServiceName);
+    RtlFreeUnicodeString(&DeviceNode->ServiceName);
 
-   if (DeviceNode->ResourceList)
-   {
-      ExFreePool(DeviceNode->ResourceList);
-   }
+    if (DeviceNode->ResourceList)
+    {
+        ExFreePool(DeviceNode->ResourceList);
+    }
 
-   if (DeviceNode->ResourceListTranslated)
-   {
-      ExFreePool(DeviceNode->ResourceListTranslated);
-   }
+    if (DeviceNode->ResourceListTranslated)
+    {
+        ExFreePool(DeviceNode->ResourceListTranslated);
+    }
 
-   if (DeviceNode->ResourceRequirements)
-   {
-      ExFreePool(DeviceNode->ResourceRequirements);
-   }
+    if (DeviceNode->ResourceRequirements)
+    {
+        ExFreePool(DeviceNode->ResourceRequirements);
+    }
 
-   if (DeviceNode->BootResources)
-   {
-      ExFreePool(DeviceNode->BootResources);
-   }
+    if (DeviceNode->BootResources)
+    {
+        ExFreePool(DeviceNode->BootResources);
+    }
 
-   ((PEXTENDED_DEVOBJ_EXTENSION)DeviceNode->PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode = NULL;
-   ExFreePoolWithTag(DeviceNode, TAG_IO_DEVNODE);
+    ((PEXTENDED_DEVOBJ_EXTENSION)DeviceNode->PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode = NULL;
+    ExFreePoolWithTag(DeviceNode, TAG_IO_DEVNODE);
 
-   return STATUS_SUCCESS;
+    return STATUS_SUCCESS;
 }
 
 NTSTATUS
@@ -1366,62 +1367,62 @@ IopInitiatePnpIrp(IN PDEVICE_OBJECT DeviceObject,
 NTSTATUS
 IopTraverseDeviceTreeNode(PDEVICETREE_TRAVERSE_CONTEXT Context)
 {
-   PDEVICE_NODE ParentDeviceNode;
-   PDEVICE_NODE ChildDeviceNode;
-   NTSTATUS Status;
+    PDEVICE_NODE ParentDeviceNode;
+    PDEVICE_NODE ChildDeviceNode;
+    NTSTATUS Status;
 
-   /* Copy context data so we don't overwrite it in subsequent calls to this function */
-   ParentDeviceNode = Context->DeviceNode;
+    /* Copy context data so we don't overwrite it in subsequent calls to this function */
+    ParentDeviceNode = Context->DeviceNode;
 
-   /* Call the action routine */
-   Status = (Context->Action)(ParentDeviceNode, Context->Context);
-   if (!NT_SUCCESS(Status))
-   {
-      return Status;
-   }
+    /* Call the action routine */
+    Status = (Context->Action)(ParentDeviceNode, Context->Context);
+    if (!NT_SUCCESS(Status))
+    {
+        return Status;
+    }
 
-   /* Traversal of all children nodes */
-   for (ChildDeviceNode = ParentDeviceNode->Child;
-        ChildDeviceNode != NULL;
-        ChildDeviceNode = ChildDeviceNode->Sibling)
-   {
-      /* Pass the current device node to the action routine */
-      Context->DeviceNode = ChildDeviceNode;
+    /* Traversal of all children nodes */
+    for (ChildDeviceNode = ParentDeviceNode->Child;
+         ChildDeviceNode != NULL;
+         ChildDeviceNode = ChildDeviceNode->Sibling)
+    {
+        /* Pass the current device node to the action routine */
+        Context->DeviceNode = ChildDeviceNode;
 
-      Status = IopTraverseDeviceTreeNode(Context);
-      if (!NT_SUCCESS(Status))
-      {
-         return Status;
-      }
-   }
+        Status = IopTraverseDeviceTreeNode(Context);
+        if (!NT_SUCCESS(Status))
+        {
+            return Status;
+        }
+    }
 
-   return Status;
+    return Status;
 }
 
 
 NTSTATUS
 IopTraverseDeviceTree(PDEVICETREE_TRAVERSE_CONTEXT Context)
 {
-   NTSTATUS Status;
+    NTSTATUS Status;
 
-   DPRINT("Context 0x%p\n", Context);
+    DPRINT("Context 0x%p\n", Context);
 
-   DPRINT("IopTraverseDeviceTree(DeviceNode 0x%p  FirstDeviceNode 0x%p  Action %p  Context 0x%p)\n",
-      Context->DeviceNode, Context->FirstDeviceNode, Context->Action, Context->Context);
+    DPRINT("IopTraverseDeviceTree(DeviceNode 0x%p  FirstDeviceNode 0x%p  Action %p  Context 0x%p)\n",
+           Context->DeviceNode, Context->FirstDeviceNode, Context->Action, Context->Context);
 
-   /* Start from the specified device node */
-   Context->DeviceNode = Context->FirstDeviceNode;
+    /* Start from the specified device node */
+    Context->DeviceNode = Context->FirstDeviceNode;
 
-   /* Recursively traverse the device tree */
-   Status = IopTraverseDeviceTreeNode(Context);
-   if (Status == STATUS_UNSUCCESSFUL)
-   {
-      /* The action routine just wanted to terminate the traversal with status
-      code STATUS_SUCCESS */
-      Status = STATUS_SUCCESS;
-   }
+    /* Recursively traverse the device tree */
+    Status = IopTraverseDeviceTreeNode(Context);
+    if (Status == STATUS_UNSUCCESSFUL)
+    {
+        /* The action routine just wanted to terminate the traversal with status
+        code STATUS_SUCCESS */
+        Status = STATUS_SUCCESS;
+    }
 
-   return Status;
+    return Status;
 }
 
 
@@ -1533,99 +1534,99 @@ NTSTATUS
 IopSetDeviceInstanceData(HANDLE InstanceKey,
                          PDEVICE_NODE DeviceNode)
 {
-   OBJECT_ATTRIBUTES ObjectAttributes;
-   UNICODE_STRING KeyName;
-   HANDLE LogConfKey;
-   ULONG ResCount;
-   ULONG ResultLength;
-   NTSTATUS Status;
-   HANDLE ControlHandle;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    UNICODE_STRING KeyName;
+    HANDLE LogConfKey;
+    ULONG ResCount;
+    ULONG ResultLength;
+    NTSTATUS Status;
+    HANDLE ControlHandle;
 
-   DPRINT("IopSetDeviceInstanceData() called\n");
+    DPRINT("IopSetDeviceInstanceData() called\n");
 
-   /* Create the 'LogConf' key */
-   RtlInitUnicodeString(&KeyName, L"LogConf");
-   InitializeObjectAttributes(&ObjectAttributes,
-                              &KeyName,
-                              OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
-                              InstanceKey,
-                              NULL);
-   Status = ZwCreateKey(&LogConfKey,
-                        KEY_ALL_ACCESS,
-                        &ObjectAttributes,
-                        0,
-                        NULL,
-                        REG_OPTION_VOLATILE,
-                        NULL);
-   if (NT_SUCCESS(Status))
-   {
-      /* Set 'BootConfig' value */
-      if (DeviceNode->BootResources != NULL)
-      {
-         ResCount = DeviceNode->BootResources->Count;
-         if (ResCount != 0)
-         {
-            RtlInitUnicodeString(&KeyName, L"BootConfig");
+    /* Create the 'LogConf' key */
+    RtlInitUnicodeString(&KeyName, L"LogConf");
+    InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
+                               InstanceKey,
+                               NULL);
+    Status = ZwCreateKey(&LogConfKey,
+                         KEY_ALL_ACCESS,
+                         &ObjectAttributes,
+                         0,
+                         NULL,
+                         REG_OPTION_VOLATILE,
+                         NULL);
+    if (NT_SUCCESS(Status))
+    {
+        /* Set 'BootConfig' value */
+        if (DeviceNode->BootResources != NULL)
+        {
+            ResCount = DeviceNode->BootResources->Count;
+            if (ResCount != 0)
+            {
+                RtlInitUnicodeString(&KeyName, L"BootConfig");
+                Status = ZwSetValueKey(LogConfKey,
+                                       &KeyName,
+                                       0,
+                                       REG_RESOURCE_LIST,
+                                       DeviceNode->BootResources,
+                                       PnpDetermineResourceListSize(DeviceNode->BootResources));
+            }
+        }
+
+        /* Set 'BasicConfigVector' value */
+        if (DeviceNode->ResourceRequirements != NULL &&
+            DeviceNode->ResourceRequirements->ListSize != 0)
+        {
+            RtlInitUnicodeString(&KeyName, L"BasicConfigVector");
             Status = ZwSetValueKey(LogConfKey,
                                    &KeyName,
                                    0,
-                                   REG_RESOURCE_LIST,
-                                   DeviceNode->BootResources,
-                                   PnpDetermineResourceListSize(DeviceNode->BootResources));
-         }
-      }
-
-      /* Set 'BasicConfigVector' value */
-      if (DeviceNode->ResourceRequirements != NULL &&
-         DeviceNode->ResourceRequirements->ListSize != 0)
-      {
-         RtlInitUnicodeString(&KeyName, L"BasicConfigVector");
-         Status = ZwSetValueKey(LogConfKey,
-                                &KeyName,
-                                0,
-                                REG_RESOURCE_REQUIREMENTS_LIST,
-                                DeviceNode->ResourceRequirements,
-                                DeviceNode->ResourceRequirements->ListSize);
-      }
+                                   REG_RESOURCE_REQUIREMENTS_LIST,
+                                   DeviceNode->ResourceRequirements,
+                                   DeviceNode->ResourceRequirements->ListSize);
+        }
 
-      ZwClose(LogConfKey);
-   }
+        ZwClose(LogConfKey);
+    }
 
-   /* Set the 'ConfigFlags' value */
-   RtlInitUnicodeString(&KeyName, L"ConfigFlags");
-   Status = ZwQueryValueKey(InstanceKey,
-                            &KeyName,
-                            KeyValueBasicInformation,
-                            NULL,
-                            0,
-                            &ResultLength);
-  if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
-  {
-    /* Write the default value */
-    ULONG DefaultConfigFlags = 0;
-    Status = ZwSetValueKey(InstanceKey,
-                           &KeyName,
-                           0,
-                           REG_DWORD,
-                           &DefaultConfigFlags,
-                           sizeof(DefaultConfigFlags));
-  }
+    /* Set the 'ConfigFlags' value */
+    RtlInitUnicodeString(&KeyName, L"ConfigFlags");
+    Status = ZwQueryValueKey(InstanceKey,
+                             &KeyName,
+                             KeyValueBasicInformation,
+                             NULL,
+                             0,
+                             &ResultLength);
+    if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
+    {
+        /* Write the default value */
+        ULONG DefaultConfigFlags = 0;
+        Status = ZwSetValueKey(InstanceKey,
+                               &KeyName,
+                               0,
+                               REG_DWORD,
+                               &DefaultConfigFlags,
+                               sizeof(DefaultConfigFlags));
+    }
 
-   /* Create the 'Control' key */
-   RtlInitUnicodeString(&KeyName, L"Control");
-   InitializeObjectAttributes(&ObjectAttributes,
-                              &KeyName,
-                              OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
-                              InstanceKey,
-                              NULL);
-   Status = ZwCreateKey(&ControlHandle, 0, &ObjectAttributes, 0, NULL, REG_OPTION_VOLATILE, NULL);
+    /* Create the 'Control' key */
+    RtlInitUnicodeString(&KeyName, L"Control");
+    InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
+                               InstanceKey,
+                               NULL);
+    Status = ZwCreateKey(&ControlHandle, 0, &ObjectAttributes, 0, NULL, REG_OPTION_VOLATILE, NULL);
 
-   if (NT_SUCCESS(Status))
-       ZwClose(ControlHandle);
+    if (NT_SUCCESS(Status))
+        ZwClose(ControlHandle);
 
-  DPRINT("IopSetDeviceInstanceData() done\n");
+    DPRINT("IopSetDeviceInstanceData() done\n");
 
-  return Status;
+    return Status;
 }
 
 /*
@@ -1756,10 +1757,10 @@ IopGetParentIdPrefix(PDEVICE_NODE DeviceNode,
 cleanup:
     if (NT_SUCCESS(Status))
     {
-       /* Duplicate the string to return it */
-       Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
-                                          &KeyValue,
-                                          ParentIdPrefix);
+        /* Duplicate the string to return it */
+        Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
+                                           &KeyValue,
+                                           ParentIdPrefix);
     }
     ExFreePoolWithTag(ParentIdPrefixInformation, TAG_IO);
     RtlFreeUnicodeString(&KeyName);
@@ -1860,134 +1861,133 @@ ErrorExit:
     // FIXME logging
     return FALSE;
 }
+
 NTSTATUS
 IopQueryHardwareIds(PDEVICE_NODE DeviceNode,
                     HANDLE InstanceKey)
 {
-   IO_STACK_LOCATION Stack;
-   IO_STATUS_BLOCK IoStatusBlock;
-   PWSTR Ptr;
-   UNICODE_STRING ValueName;
-   NTSTATUS Status;
-   ULONG Length, TotalLength;
-   BOOLEAN IsValidID;
+    IO_STACK_LOCATION Stack;
+    IO_STATUS_BLOCK IoStatusBlock;
+    PWSTR Ptr;
+    UNICODE_STRING ValueName;
+    NTSTATUS Status;
+    ULONG Length, TotalLength;
+    BOOLEAN IsValidID;
 
-   DPRINT("Sending IRP_MN_QUERY_ID.BusQueryHardwareIDs to device stack\n");
+    DPRINT("Sending IRP_MN_QUERY_ID.BusQueryHardwareIDs to device stack\n");
 
-   RtlZeroMemory(&Stack, sizeof(Stack));
-   Stack.Parameters.QueryId.IdType = BusQueryHardwareIDs;
-   Status = IopInitiatePnpIrp(DeviceNode->PhysicalDeviceObject,
-                              &IoStatusBlock,
-                              IRP_MN_QUERY_ID,
-                              &Stack);
-   if (NT_SUCCESS(Status))
-   {
-      IsValidID = IopValidateID((PWCHAR)IoStatusBlock.Information, BusQueryHardwareIDs);
+    RtlZeroMemory(&Stack, sizeof(Stack));
+    Stack.Parameters.QueryId.IdType = BusQueryHardwareIDs;
+    Status = IopInitiatePnpIrp(DeviceNode->PhysicalDeviceObject,
+                               &IoStatusBlock,
+                               IRP_MN_QUERY_ID,
+                               &Stack);
+    if (NT_SUCCESS(Status))
+    {
+        IsValidID = IopValidateID((PWCHAR)IoStatusBlock.Information, BusQueryHardwareIDs);
 
-      if (!IsValidID)
-      {
-         DPRINT1("Invalid HardwareIDs. DeviceNode - %p\n", DeviceNode);
-      }
+        if (!IsValidID)
+        {
+            DPRINT1("Invalid HardwareIDs. DeviceNode - %p\n", DeviceNode);
+        }
 
-      TotalLength = 0;
+        TotalLength = 0;
 
-      Ptr = (PWSTR)IoStatusBlock.Information;
-      DPRINT("Hardware IDs:\n");
-      while (*Ptr)
-      {
-         DPRINT("  %S\n", Ptr);
-         Length = (ULONG)wcslen(Ptr) + 1;
+        Ptr = (PWSTR)IoStatusBlock.Information;
+        DPRINT("Hardware IDs:\n");
+        while (*Ptr)
+        {
+            DPRINT("  %S\n", Ptr);
+            Length = (ULONG)wcslen(Ptr) + 1;
 
-         Ptr += Length;
-         TotalLength += Length;
-      }
-      DPRINT("TotalLength: %hu\n", TotalLength);
-      DPRINT("\n");
-
-      RtlInitUnicodeString(&ValueName, L"HardwareID");
-      Status = ZwSetValueKey(InstanceKey,
-                 &ValueName,
-                 0,
-                 REG_MULTI_SZ,
-                 (PVOID)IoStatusBlock.Information,
-                 (TotalLength + 1) * sizeof(WCHAR));
-      if (!NT_SUCCESS(Status))
-      {
-         DPRINT1("ZwSetValueKey() failed (Status %lx)\n", Status);
-      }
-   }
-   else
-   {
-      DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
-   }
+            Ptr += Length;
+            TotalLength += Length;
+        }
+        DPRINT("TotalLength: %hu\n", TotalLength);
+        DPRINT("\n");
 
-   return Status;
+        RtlInitUnicodeString(&ValueName, L"HardwareID");
+        Status = ZwSetValueKey(InstanceKey,
+                               &ValueName,
+                               0,
+                               REG_MULTI_SZ,
+                               (PVOID)IoStatusBlock.Information,
+                               (TotalLength + 1) * sizeof(WCHAR));
+        if (!NT_SUCCESS(Status))
+        {
+            DPRINT1("ZwSetValueKey() failed (Status %lx)\n", Status);
+        }
+    }
+    else
+    {
+        DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
+    }
+
+    return Status;
 }
 
 NTSTATUS
 IopQueryCompatibleIds(PDEVICE_NODE DeviceNode,
                       HANDLE InstanceKey)
 {
-   IO_STACK_LOCATION Stack;
-   IO_STATUS_BLOCK IoStatusBlock;
-   PWSTR Ptr;
-   UNICODE_STRING ValueName;
-   NTSTATUS Status;
-   ULONG Length, TotalLength;
-   BOOLEAN IsValidID;
-
-   DPRINT("Sending IRP_MN_QUERY_ID.BusQueryCompatibleIDs to device stack\n");
-
-   RtlZeroMemory(&Stack, sizeof(Stack));
-   Stack.Parameters.QueryId.IdType = BusQueryCompatibleIDs;
-   Status = IopInitiatePnpIrp(
-      DeviceNode->PhysicalDeviceObject,
-      &IoStatusBlock,
-      IRP_MN_QUERY_ID,
-      &Stack);
-   if (NT_SUCCESS(Status) && IoStatusBlock.Information)
-   {
-      IsValidID = IopValidateID((PWCHAR)IoStatusBlock.Information, BusQueryCompatibleIDs);
+    IO_STACK_LOCATION Stack;
+    IO_STATUS_BLOCK IoStatusBlock;
+    PWSTR Ptr;
+    UNICODE_STRING ValueName;
+    NTSTATUS Status;
+    ULONG Length, TotalLength;
+    BOOLEAN IsValidID;
 
-      if (!IsValidID)
-      {
-         DPRINT1("Invalid CompatibleIDs. DeviceNode - %p\n", DeviceNode);
-      }
+    DPRINT("Sending IRP_MN_QUERY_ID.BusQueryCompatibleIDs to device stack\n");
 
-      TotalLength = 0;
+    RtlZeroMemory(&Stack, sizeof(Stack));
+    Stack.Parameters.QueryId.IdType = BusQueryCompatibleIDs;
+    Status = IopInitiatePnpIrp(DeviceNode->PhysicalDeviceObject,
+                               &IoStatusBlock,
+                               IRP_MN_QUERY_ID,
+                               &Stack);
+    if (NT_SUCCESS(Status) && IoStatusBlock.Information)
+    {
+        IsValidID = IopValidateID((PWCHAR)IoStatusBlock.Information, BusQueryCompatibleIDs);
 
-      Ptr = (PWSTR)IoStatusBlock.Information;
-      DPRINT("Compatible IDs:\n");
-      while (*Ptr)
-      {
-         DPRINT("  %S\n", Ptr);
-         Length = (ULONG)wcslen(Ptr) + 1;
+        if (!IsValidID)
+        {
+            DPRINT1("Invalid CompatibleIDs. DeviceNode - %p\n", DeviceNode);
+        }
 
-         Ptr += Length;
-         TotalLength += Length;
-      }
-      DPRINT("TotalLength: %hu\n", TotalLength);
-      DPRINT("\n");
+        TotalLength = 0;
 
-      RtlInitUnicodeString(&ValueName, L"CompatibleIDs");
-      Status = ZwSetValueKey(InstanceKey,
-                             &ValueName,
-                             0,
-                             REG_MULTI_SZ,
-                             (PVOID)IoStatusBlock.Information,
-                             (TotalLength + 1) * sizeof(WCHAR));
-      if (!NT_SUCCESS(Status))
-      {
-         DPRINT1("ZwSetValueKey() failed (Status %lx) or no Compatible ID returned\n", Status);
-      }
-   }
-   else
-   {
-      DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
-   }
+        Ptr = (PWSTR)IoStatusBlock.Information;
+        DPRINT("Compatible IDs:\n");
+        while (*Ptr)
+        {
+            DPRINT("  %S\n", Ptr);
+            Length = (ULONG)wcslen(Ptr) + 1;
 
-   return Status;
+            Ptr += Length;
+            TotalLength += Length;
+        }
+        DPRINT("TotalLength: %hu\n", TotalLength);
+        DPRINT("\n");
+
+        RtlInitUnicodeString(&ValueName, L"CompatibleIDs");
+        Status = ZwSetValueKey(InstanceKey,
+                               &ValueName,
+                               0,
+                               REG_MULTI_SZ,
+                               (PVOID)IoStatusBlock.Information,
+                               (TotalLength + 1) * sizeof(WCHAR));
+        if (!NT_SUCCESS(Status))
+        {
+            DPRINT1("ZwSetValueKey() failed (Status %lx) or no Compatible ID returned\n", Status);
+        }
+    }
+    else
+    {
+        DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
+    }
+
+    return Status;
 }
 
 NTSTATUS