#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for pnpinit.c:

Macros
#define	NDEBUG

Functions
NTSTATUS NTAPI	IopArbPortInitialize (VOID)
	Initialize the RootPortArbiter.

NTSTATUS NTAPI	IopArbMemInitialize (VOID)
	Initialize the RootMemoryArbiter.

NTSTATUS NTAPI	IopArbDmaInitialize (VOID)
	Initialize the RootDmaArbiter.

NTSTATUS NTAPI	IopArbIrqInitialize (VOID)
	Initialize the root IRQ arbiter.

NTSTATUS NTAPI	IopArbBusNumberInitialize (VOID)
	Initialize the RootBusArbiter.

INTERFACE_TYPE NTAPI	IopDetermineDefaultInterfaceType (VOID)

NTSTATUS NTAPI	IopInitializeArbiters (VOID)

NTSTATUS NTAPI	PiInitCacheGroupInformation (VOID)

USHORT NTAPI	PpInitGetGroupOrderIndex (IN HANDLE ServiceHandle)

USHORT NTAPI	PipGetDriverTagPriority (IN HANDLE ServiceHandle)

NTSTATUS NTAPI	IopInitializePlugPlayServices (VOID)

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 12 of file pnpinit.c.

Function Documentation

◆ IopArbBusNumberInitialize()

NTSTATUS NTAPI IopArbBusNumberInitialize ( VOID )

Initialize the RootBusArbiter.

The root bus-number arbiter owns the flat 0..255 bus-number space and hands each bridge a sub-range.

Returns: NTSTATUS

Return values

STATUS_SUCCESS
STATUS_UNSUCCESSFUL
STATUS_INSUFFICIENT_RESOURCES

Definition at line 100 of file arbbus.c.

{
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
 
    PAGED_CODE();
    IopRootBusNumberArbiter.Name = L"RootBusNumber";
    IopRootBusNumberArbiter.UnpackRequirement = IopArbBusNumberUnpackRequirements;
    IopRootBusNumberArbiter.PackResource = IopArbBusNumberPackResource;
    IopRootBusNumberArbiter.UnpackResource = IopArbBusNumberUnpackResource;
    IopRootBusNumberArbiter.ScoreRequirement = IopArbBusNumberScoreRequirement;
 
    Status = ArbiterLibInitializeInstance(&IopRootBusNumberArbiter,
                                          NULL,
                                          CmResourceTypeBusNumber,
                                          IopRootBusNumberArbiter.Name,
                                          L"Root",
                                          NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbBusNumberInitialize: Failed with %X\n", Status);
    }
 
    return Status;
}

Referenced by IopInitializeArbiters().

◆ IopArbDmaInitialize()

NTSTATUS NTAPI IopArbDmaInitialize ( VOID )

Initialize the RootDmaArbiter.

Returns: NTSTATUS

Return values

STATUS_SUCCESS
STATUS_UNSUCCESSFUL
STATUS_INSUFFICIENT_RESOURCES

Definition at line 134 of file arbdma.c.

{
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
 
    PAGED_CODE();
    IopRootDmaArbiter.Name = L"RootDMA";
    IopRootDmaArbiter.UnpackRequirement = IopArbDmaUnpackRequirements;
    IopRootDmaArbiter.PackResource = IopArbDmaPackResource;
    IopRootDmaArbiter.UnpackResource = IopArbDmaUnpackResource;
    IopRootDmaArbiter.ScoreRequirement = IopArbDmaScoreRequirement;
    IopRootDmaArbiter.OverrideConflict = IopArbDmaOverrideConflict;
 
    Status = ArbiterLibInitializeInstance(&IopRootDmaArbiter,
                                          NULL,
                                          CmResourceTypeDma,
                                          IopRootDmaArbiter.Name,
                                          L"Root",
                                          NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbDmaInitialize: Failed with %X\n", Status);
    }
 
    return Status;
}

Referenced by IopInitializeArbiters().

◆ IopArbIrqInitialize()

NTSTATUS NTAPI IopArbIrqInitialize ( VOID )

Initialize the root IRQ arbiter.

This is the fallback that sits at the top of the tree and takes over when no closer arbiter claims the request, e.g root-enumerated / HAL legacy devices (ISA-style, directly under the root), and platforms or boot paths where no bus driver above the device provides an interrupt arbiter (e.g. no ACPI _PRT routing in effect).

In those cases the arbitrated "vectors" are the legacy ISA IRQ lines, which is why IopArbIrqTranslateOrdering maps the ordering table through HalGetInterruptVector for the ISA bus. Otherwise, such devices would have nowhere to arbitrate their interrupts. (So this is purely for legacy PIC + No ACPI)

Returns: NTSTATUS

Return values

STATUS_SUCCESS
STATUS_UNSUCCESSFUL
STATUS_INSUFFICIENT_RESOURCES

Definition at line 149 of file arbirq.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    IopRootIrqArbiter.Name = L"RootIRQ";
    IopRootIrqArbiter.UnpackRequirement = IopArbIrqUnpackRequirements;
    IopRootIrqArbiter.PackResource = IopArbIrqPackResource;
    IopRootIrqArbiter.UnpackResource = IopArbIrqUnpackResource;
    IopRootIrqArbiter.ScoreRequirement = IopArbIrqScoreRequirement;
 
    Status = ArbiterLibInitializeInstance(&IopRootIrqArbiter,
                                          NULL,
                                          CmResourceTypeInterrupt,
                                          IopRootIrqArbiter.Name,
                                          L"Root",
                                          IopArbIrqTranslateOrdering);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbIrqInitialize: Failed with %X\n", Status);
    }
 
    return Status;
}

Referenced by IopInitializeArbiters().

◆ IopArbMemInitialize()

NTSTATUS NTAPI IopArbMemInitialize ( VOID )

Initialize the RootMemoryArbiter.

The root memory arbiter owns CPU physical address space and hands each device the MMIO window it decodes. It is the fallback for every device whose memory no closer arbiter claims.

The physical page 0 is reserved with no attributes at all, so that no availability mask can hand it out: the real-mode interrupt vector table and the BIOS data area live there, and a device decoding over them corrupts the machine rather than merely failing.

Returns: NTSTATUS

Return values

STATUS_SUCCESS
STATUS_UNSUCCESSFUL
STATUS_INSUFFICIENT_RESOURCES

Definition at line 415 of file arbmem.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    IopRootMemArbiter.Name = L"RootMemory";
    IopRootMemArbiter.UnpackRequirement = IopArbMemUnpackRequirements;
    IopRootMemArbiter.PackResource = IopArbMemPackResource;
    IopRootMemArbiter.UnpackResource = IopArbMemUnpackResource;
    IopRootMemArbiter.ScoreRequirement = IopArbMemScoreRequirement;
    IopRootMemArbiter.FindSuitableRange = IopArbMemFindSuitableRange;
 
    Status = ArbiterLibInitializeInstance(&IopRootMemArbiter,
                                          NULL,
                                          CmResourceTypeMemory,
                                          IopRootMemArbiter.Name,
                                          L"Root",
                                          IopArbMemTranslateOrdering);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbMemInitialize: Failed with %X\n", Status);
        return Status;
    }
 
    Status = RtlAddRange(IopRootMemArbiter.Allocation, 0ULL, 0xFFFULL, 0, 0, NULL, NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbMemInitialize: Reserving page 0 failed with %X\n", Status);
    }
 
    return Status;
}

Referenced by IopInitializeArbiters().

◆ IopArbPortInitialize()

NTSTATUS NTAPI IopArbPortInitialize ( VOID )

Initialize the RootPortArbiter.

The root port arbiter owns the 16-bit x86 I/O port space and hands out sub-ranges of it. It is the fallback for every device whose ports no closer arbiter claims: root-enumerated and HAL-reported legacy hardware above all, which is also the hardware that partially decodes its address lines and so needs the aliasing this arbiter adds.

Returns: NTSTATUS

Return values

STATUS_SUCCESS
STATUS_UNSUCCESSFUL
STATUS_INSUFFICIENT_RESOURCES

Definition at line 557 of file arbport.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    IopRootPortArbiter.Name = L"RootPort";
    IopRootPortArbiter.UnpackRequirement = IopArbPortUnpackRequirements;
    IopRootPortArbiter.PackResource = IopArbPortPackResource;
    IopRootPortArbiter.UnpackResource = IopArbPortUnpackResource;
    IopRootPortArbiter.ScoreRequirement = IopArbPortScoreRequirement;
 
    /* Port-specific placement: boot-config leniency and ISA decode aliasing. */
    IopRootPortArbiter.FindSuitableRange = IopArbPortFindSuitableRange;
    IopRootPortArbiter.AddAllocation = IopArbPortAddAllocation;
    IopRootPortArbiter.BacktrackAllocation = IopArbPortBacktrackAllocation;
 
    Status = ArbiterLibInitializeInstance(&IopRootPortArbiter,
                                          NULL,
                                          CmResourceTypePort,
                                          IopRootPortArbiter.Name,
                                          L"Root",
                                          IopArbPortTranslateOrdering);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbPortInitialize: Failed with %X\n", Status);
    }
 
    return Status;
}

Referenced by IopInitializeArbiters().

◆ IopDetermineDefaultInterfaceType()

INTERFACE_TYPE NTAPI IopDetermineDefaultInterfaceType ( VOID )

Definition at line 41 of file pnpinit.c.

{
    /* FIXME: ReactOS doesn't support MicroChannel yet */
    return Isa;
}

Referenced by IopInitializePlugPlayServices().

◆ IopInitializeArbiters()

NTSTATUS NTAPI IopInitializeArbiters ( VOID )

Definition at line 49 of file pnpinit.c.

{
    NTSTATUS Status;
 
    Status = IopArbPortInitialize();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbPortInitialize() return %X\n", Status);
        return Status;
    }
 
    Status = IopArbMemInitialize();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbMemInitialize() return %X\n", Status);
        return Status;
    }
 
    Status = IopArbDmaInitialize();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbDmaInitialize() return %X\n", Status);
        return Status;
    }
 
    Status = IopArbIrqInitialize();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbIrqInitialize() return %X\n", Status);
        return Status;
    }
 
    Status = IopArbBusNumberInitialize();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbBusNumberInitialize() return %X\n", Status);
    }
 
    return Status;
}

Referenced by IopInitializePlugPlayServices().

◆ IopInitializePlugPlayServices()

NTSTATUS NTAPI IopInitializePlugPlayServices ( VOID )

Definition at line 287 of file pnpinit.c.

{
    NTSTATUS Status;
    ULONG Disposition;
    HANDLE KeyHandle, EnumHandle, ParentHandle, TreeHandle, ControlHandle;
    UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET");
    UNICODE_STRING PnpManagerDriverName = RTL_CONSTANT_STRING(DRIVER_ROOT_NAME L"PnpManager");
    PDEVICE_OBJECT Pdo;
 
    /* Initialize locks and such */
    KeInitializeSpinLock(&IopDeviceTreeLock);
    KeInitializeSpinLock(&IopDeviceActionLock);
    InitializeListHead(&IopDeviceActionRequestList);
    KeInitializeEvent(&PiEnumerationFinished, NotificationEvent, TRUE);
 
    /* Get the default interface */
    PnpDefaultInterfaceType = IopDetermineDefaultInterfaceType();
 
#if 0 /* FIXME: Dont even try yet! */
    /* Initialize arbiters */
    Status = IopInitializeArbiters();
    if (!NT_SUCCESS(Status)) return Status;
#endif
 
    /* Setup the group cache */
    Status = PiInitCacheGroupInformation();
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Open the current control set */
    Status = IopOpenRegistryKeyEx(&KeyHandle,
                                  NULL,
                                  &KeyName,
                                  KEY_ALL_ACCESS);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Create the control key */
    RtlInitUnicodeString(&KeyName, L"Control");
    Status = IopCreateRegistryKeyEx(&ControlHandle,
                                    KeyHandle,
                                    &KeyName,
                                    KEY_ALL_ACCESS,
                                    REG_OPTION_NON_VOLATILE,
                                    &Disposition);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Check if it's a new key */
    if (Disposition == REG_CREATED_NEW_KEY)
    {
        HANDLE DeviceClassesHandle;
 
        /* Create the device classes key */
        RtlInitUnicodeString(&KeyName, L"DeviceClasses");
        Status = IopCreateRegistryKeyEx(&DeviceClassesHandle,
                                        ControlHandle,
                                        &KeyName,
                                        KEY_ALL_ACCESS,
                                        REG_OPTION_NON_VOLATILE,
                                        &Disposition);
        if (!NT_SUCCESS(Status)) return Status;
 
        ZwClose(DeviceClassesHandle);
    }
 
    ZwClose(ControlHandle);
 
    /* Create the enum key */
    RtlInitUnicodeString(&KeyName, REGSTR_KEY_ENUM);
    Status = IopCreateRegistryKeyEx(&EnumHandle,
                                    KeyHandle,
                                    &KeyName,
                                    KEY_ALL_ACCESS,
                                    REG_OPTION_NON_VOLATILE,
                                    &Disposition);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Check if it's a new key */
    if (Disposition == REG_CREATED_NEW_KEY)
    {
        /* FIXME: DACLs */
    }
 
    /* Create the root key */
    ParentHandle = EnumHandle;
    RtlInitUnicodeString(&KeyName, REGSTR_KEY_ROOTENUM);
    Status = IopCreateRegistryKeyEx(&EnumHandle,
                                    ParentHandle,
                                    &KeyName,
                                    KEY_ALL_ACCESS,
                                    REG_OPTION_NON_VOLATILE,
                                    &Disposition);
    NtClose(ParentHandle);
    if (!NT_SUCCESS(Status)) return Status;
    NtClose(EnumHandle);
 
    /* Open the root key now */
    RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET\\ENUM");
    Status = IopOpenRegistryKeyEx(&EnumHandle,
                                  NULL,
                                  &KeyName,
                                  KEY_ALL_ACCESS);
    if (NT_SUCCESS(Status))
    {
        /* Create the root dev node */
        RtlInitUnicodeString(&KeyName, REGSTR_VAL_ROOT_DEVNODE);
        Status = IopCreateRegistryKeyEx(&TreeHandle,
                                        EnumHandle,
                                        &KeyName,
                                        KEY_ALL_ACCESS,
                                        REG_OPTION_NON_VOLATILE,
                                        NULL);
        NtClose(EnumHandle);
        if (NT_SUCCESS(Status)) NtClose(TreeHandle);
    }
 
    /* Create the root driver */
    Status = IoCreateDriver(&PnpManagerDriverName, PnpRootDriverEntry);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IoCreateDriverObject() failed\n");
        KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
    }
 
    /* Create the root PDO */
    Status = IoCreateDevice(IopRootDriverObject,
                            0,
                            NULL,
                            FILE_DEVICE_CONTROLLER,
                            0,
                            FALSE,
                            &Pdo);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IoCreateDevice() failed\n");
        KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
    }
 
    /* This is a bus enumerated device */
    Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
 
    /* Create the root device node */
    IopRootDeviceNode = PipAllocateDeviceNode(Pdo);
 
    /* Set flags */
    IopRootDeviceNode->Flags |= DNF_MADEUP | DNF_ENUMERATED |
                                DNF_IDS_QUERIED | DNF_NO_RESOURCE_REQUIRED;
 
    /* Create instance path */
    if (!RtlCreateUnicodeString(&IopRootDeviceNode->InstancePath, REGSTR_VAL_ROOT_DEVNODE))
    {
        DPRINT1("RtlCreateUnicodeString() failed\n");
        KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
    }
 
    PnpRootInitializeDevExtension();
 
    PiSetDevNodeState(IopRootDeviceNode, DeviceNodeStarted);
 
    /* Initialize PnP-Event notification support */
    Status = IopInitPlugPlayEvents();
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Initialize the Bus Type GUID List */
    ExInitializeFastMutex(&PnpBusTypeGuidList.Lock);
    PnpBusTypeGuidList.AllocatedCount = 8;
    PnpBusTypeGuidList.GuidCount = 0;
    PnpBusTypeGuidList.Guids = ExAllocatePoolWithTag(PagedPool,
                                                     PnpBusTypeGuidList.AllocatedCount * sizeof(GUID),
                                                     TAG_PNP_GUIDS);
    if (PnpBusTypeGuidList.Guids == NULL)
    {
        DPRINT1("Failed to allocate PnP GUID buffer!\n");
        KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, STATUS_NO_MEMORY, 0, 0, 0);
    }
    RtlZeroMemory(PnpBusTypeGuidList.Guids, PnpBusTypeGuidList.AllocatedCount * sizeof(GUID));
 
    /* Initialize PnP root relations (this is a syncronous operation) */
    PiQueueDeviceAction(Pdo, PiActionEnumRootDevices, NULL, NULL);
 
    /* Launch the firmware mapper */
    Status = IopUpdateRootKey();
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Close the handle to the control set */
    NtClose(KeyHandle);
 
    /* Initialize PnP root relations (this is a syncronous operation) */
    PiQueueDeviceAction(Pdo, PiActionEnumRootDevices, NULL, NULL);
 
    /* We made it */
    return STATUS_SUCCESS;
}

Referenced by IoInitSystem().

◆ PiInitCacheGroupInformation()

NTSTATUS NTAPI PiInitCacheGroupInformation ( VOID )

Definition at line 94 of file pnpinit.c.

{
    HANDLE KeyHandle;
    NTSTATUS Status;
    PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
    PUNICODE_STRING GroupTable;
    ULONG Count;
    UNICODE_STRING GroupString =
        RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet"
                            L"\\Control\\ServiceGroupOrder");
 
    /* Open the registry key */
    Status = IopOpenRegistryKeyEx(&KeyHandle,
                                  NULL,
                                  &GroupString,
                                  KEY_READ);
    if (NT_SUCCESS(Status))
    {
        /* Get the list */
        Status = IopGetRegistryValue(KeyHandle, L"List", &KeyValueInformation);
        ZwClose(KeyHandle);
 
        /* Make sure we got it */
        if (NT_SUCCESS(Status))
        {
            /* Make sure it's valid */
            if ((KeyValueInformation->Type == REG_MULTI_SZ) &&
                (KeyValueInformation->DataLength))
            {
                /* Convert it to unicode strings */
                Status = PnpRegMultiSzToUnicodeStrings(KeyValueInformation,
                                                       &GroupTable,
                                                       &Count);
 
                /* Cache it for later */
                PiInitGroupOrderTable = GroupTable;
                PiInitGroupOrderTableCount = (USHORT)Count;
            }
            else
            {
                /* Fail */
                Status = STATUS_UNSUCCESSFUL;
            }
 
            /* Free the information */
            ExFreePool(KeyValueInformation);
        }
    }
 
    /* Return status */
    return Status;
}

Referenced by IopInitializePlugPlayServices().

◆ PipGetDriverTagPriority()

USHORT NTAPI PipGetDriverTagPriority ( IN HANDLE ServiceHandle )

Definition at line 192 of file pnpinit.c.

{
    NTSTATUS Status;
    HANDLE KeyHandle = NULL;
    PKEY_VALUE_FULL_INFORMATION KeyValueInformation = NULL;
    PKEY_VALUE_FULL_INFORMATION KeyValueInformationTag;
    PKEY_VALUE_FULL_INFORMATION KeyValueInformationGroupOrderList;
    PVOID Buffer;
    UNICODE_STRING Group;
    PULONG GroupOrder;
    ULONG Count, Tag = 0;
    USHORT i = -1;
    UNICODE_STRING GroupString =
    RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet"
                        L"\\Control\\ServiceGroupOrder");
 
    /* Open the key */
    Status = IopOpenRegistryKeyEx(&KeyHandle, NULL, &GroupString, KEY_READ);
    if (!NT_SUCCESS(Status)) goto Quickie;
 
    /* Read the group */
    Status = IopGetRegistryValue(ServiceHandle, L"Group", &KeyValueInformation);
    if (!NT_SUCCESS(Status)) goto Quickie;
 
    /* Make sure we have a group */
    if ((KeyValueInformation->Type == REG_SZ) &&
        (KeyValueInformation->DataLength))
    {
        /* Convert to unicode string */
        Buffer = (PVOID)((ULONG_PTR)KeyValueInformation + KeyValueInformation->DataOffset);
        PnpRegSzToString(Buffer, KeyValueInformation->DataLength, &Group.Length);
        Group.MaximumLength = (USHORT)KeyValueInformation->DataLength;
        Group.Buffer = Buffer;
    }
 
    /* Now read the tag */
    Status = IopGetRegistryValue(ServiceHandle, L"Tag", &KeyValueInformationTag);
    if (!NT_SUCCESS(Status)) goto Quickie;
 
    /* Make sure we have a tag */
    if ((KeyValueInformationTag->Type == REG_DWORD) &&
        (KeyValueInformationTag->DataLength))
    {
        /* Read it */
        Tag = *(PULONG)((ULONG_PTR)KeyValueInformationTag +
                        KeyValueInformationTag->DataOffset);
    }
 
    /* We can get rid of this now */
    ExFreePool(KeyValueInformationTag);
 
    /* Now let's read the group's tag order */
    Status = IopGetRegistryValue(KeyHandle,
                                 Group.Buffer,
                                 &KeyValueInformationGroupOrderList);
 
    /* We can get rid of this now */
Quickie:
    if (KeyValueInformation) ExFreePool(KeyValueInformation);
    if (KeyHandle) NtClose(KeyHandle);
    if (!NT_SUCCESS(Status)) return -1;
 
    /* We're on the success path -- validate the tag order*/
    if ((KeyValueInformationGroupOrderList->Type == REG_BINARY) &&
        (KeyValueInformationGroupOrderList->DataLength))
    {
        /* Get the order array */
        GroupOrder = (PULONG)((ULONG_PTR)KeyValueInformationGroupOrderList +
                              KeyValueInformationGroupOrderList->DataOffset);
 
        /* Get the count */
        Count = *GroupOrder;
        ASSERT(((Count + 1) * sizeof(ULONG)) <=
               KeyValueInformationGroupOrderList->DataLength);
 
        /* Now loop each tag */
        GroupOrder++;
        for (i = 1; i <= Count; i++)
        {
            /* If we found it, we're out */
            if (Tag == *GroupOrder) break;
 
            /* Try the next one */
            GroupOrder++;
        }
    }
 
    /* Last buffer to free */
    ExFreePool(KeyValueInformationGroupOrderList);
    return i;
}

Referenced by IopInitializeBootDrivers().

◆ PpInitGetGroupOrderIndex()

USHORT NTAPI PpInitGetGroupOrderIndex ( IN HANDLE ServiceHandle )

Definition at line 149 of file pnpinit.c.

{
    NTSTATUS Status;
    PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
    USHORT i;
    PVOID Buffer;
    UNICODE_STRING Group;
    PAGED_CODE();
 
    /* Make sure we have a cache */
    if (!PiInitGroupOrderTable) return -1;
 
    /* If we don't have a handle, the rest is easy -- return the count */
    if (!ServiceHandle) return PiInitGroupOrderTableCount + 1;
 
    /* Otherwise, get the group value */
    Status = IopGetRegistryValue(ServiceHandle, L"Group", &KeyValueInformation);
    if (!NT_SUCCESS(Status)) return PiInitGroupOrderTableCount;
 
    /* Make sure we have a valid string */
    ASSERT(KeyValueInformation->Type == REG_SZ);
    ASSERT(KeyValueInformation->DataLength);
 
    /* Convert to unicode string */
    Buffer = (PVOID)((ULONG_PTR)KeyValueInformation + KeyValueInformation->DataOffset);
    PnpRegSzToString(Buffer, KeyValueInformation->DataLength, &Group.Length);
    Group.MaximumLength = (USHORT)KeyValueInformation->DataLength;
    Group.Buffer = Buffer;
 
    /* Loop the groups */
    for (i = 0; i < PiInitGroupOrderTableCount; i++)
    {
        /* Try to find a match */
        if (RtlEqualUnicodeString(&Group, &PiInitGroupOrderTable[i], TRUE)) break;
    }
 
    /* We're done */
    ExFreePool(KeyValueInformation);
    return i;
}

Referenced by IopInitializeBootDrivers().

Variable Documentation

◆ IopRootBusNumberArbiter

ARBITER_INSTANCE IopRootBusNumberArbiter

Definition at line 23 of file pnpinit.c.

Referenced by IopArbBusNumberInitialize().

◆ IopRootDmaArbiter

ARBITER_INSTANCE IopRootDmaArbiter

Definition at line 25 of file pnpinit.c.

Referenced by IopArbDmaInitialize().

◆ IopRootIrqArbiter

ARBITER_INSTANCE IopRootIrqArbiter

Definition at line 24 of file pnpinit.c.

Referenced by IopArbIrqInitialize().

◆ IopRootMemArbiter

ARBITER_INSTANCE IopRootMemArbiter

Definition at line 26 of file pnpinit.c.

Referenced by IopArbMemInitialize().

◆ IopRootPortArbiter

ARBITER_INSTANCE IopRootPortArbiter

Definition at line 27 of file pnpinit.c.

Referenced by IopArbPortInitialize().

◆ PiEnumerationFinished

KEVENT PiEnumerationFinished

extern

Definition at line 50 of file devaction.c.

Referenced by IopInitializePlugPlayServices(), PipDeviceActionWorker(), and PiQueueDeviceAction().

◆ PiInitGroupOrderTable

PUNICODE_STRING PiInitGroupOrderTable

Definition at line 17 of file pnpinit.c.

Referenced by PiInitCacheGroupInformation(), and PpInitGetGroupOrderIndex().

◆ PiInitGroupOrderTableCount

USHORT PiInitGroupOrderTableCount

Definition at line 18 of file pnpinit.c.

Referenced by PiInitCacheGroupInformation(), and PpInitGetGroupOrderIndex().

◆ PnPBootDriversInitialized

BOOLEAN PnPBootDriversInitialized = FALSE

Definition at line 21 of file pnpinit.c.

Referenced by IoInitSystem(), PiDevNodeStateMachine(), and PipDeviceActionWorker().

◆ PnPBootDriversLoaded

BOOLEAN PnPBootDriversLoaded = FALSE

Definition at line 20 of file pnpinit.c.

Referenced by IopInitializeBootDrivers(), and PiQueueDeviceAction().

◆ PnpDefaultInterfaceType

INTERFACE_TYPE PnpDefaultInterfaceType

Definition at line 19 of file pnpinit.c.

Referenced by IopInitializePlugPlayServices().

Variables
PUNICODE_STRING	PiInitGroupOrderTable

USHORT	PiInitGroupOrderTableCount

INTERFACE_TYPE	PnpDefaultInterfaceType

BOOLEAN	PnPBootDriversLoaded = FALSE

BOOLEAN	PnPBootDriversInitialized = FALSE

ARBITER_INSTANCE	IopRootBusNumberArbiter

ARBITER_INSTANCE	IopRootIrqArbiter

ARBITER_INSTANCE	IopRootDmaArbiter

ARBITER_INSTANCE	IopRootMemArbiter

ARBITER_INSTANCE	IopRootPortArbiter

KEVENT	PiEnumerationFinished

Macros

Functions

Variables

Macro Definition Documentation

◆ NDEBUG

Function Documentation

◆ IopArbBusNumberInitialize()

◆ IopArbDmaInitialize()

◆ IopArbIrqInitialize()

◆ IopArbMemInitialize()

◆ IopArbPortInitialize()

◆ IopDetermineDefaultInterfaceType()

◆ IopInitializeArbiters()

◆ IopInitializePlugPlayServices()

◆ PiInitCacheGroupInformation()

◆ PipGetDriverTagPriority()

◆ PpInitGetGroupOrderIndex()

Variable Documentation

◆ IopRootBusNumberArbiter

◆ IopRootDmaArbiter

◆ IopRootIrqArbiter

◆ IopRootMemArbiter

◆ IopRootPortArbiter

◆ PiEnumerationFinished

◆ PiInitGroupOrderTable

◆ PiInitGroupOrderTableCount

◆ PnPBootDriversInitialized

◆ PnPBootDriversLoaded

◆ PnpDefaultInterfaceType