pnpinit.c File Reference

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

Include dependency graph for pnpinit.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
NTSTATUS NTAPI	IopArbPortInitialize (VOID)
NTSTATUS NTAPI	IopArbMemInitialize (VOID)
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)

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

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", 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 106 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;
 
    Status = ArbiterLibInitializeInstance(&IopRootDmaArbiter,
                                          NULL,
                                          CmResourceTypeDma,
                                          IopRootDmaArbiter.Name,
                                          L"Root",
                                          NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbDmaInitialize: Failed with %X", 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

)

Definition at line 90 of file arbmem.c.

{
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
 
    PAGED_CODE();
    IopRootMemArbiter.Name = L"RootMemory";
    IopRootMemArbiter.UnpackRequirement = IopArbMemUnpackRequirements;
    IopRootMemArbiter.PackResource = IopArbMemPackResource;
    IopRootMemArbiter.UnpackResource = IopArbMemUnpackResource;
    IopRootMemArbiter.ScoreRequirement = IopArbMemScoreRequirement;
 
    Status = ArbiterLibInitializeInstance(&IopRootMemArbiter,
                                          NULL,
                                          CmResourceTypeMemory,
                                          IopRootMemArbiter.Name,
                                          L"Root",
                                          NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbMemInitialize: Failed with %X", Status);
    }
 
    return Status;
}

Referenced by IopInitializeArbiters().

IopArbPortInitialize()

NTSTATUS NTAPI IopArbPortInitialize

(

VOID

)

Definition at line 90 of file arbport.c.

{
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
 
    PAGED_CODE();
    IopRootPortArbiter.Name = L"RootPort";
    IopRootPortArbiter.UnpackRequirement = IopPortMemUnpackRequirements;
    IopRootPortArbiter.PackResource = IopPortMemPackResource;
    IopRootPortArbiter.UnpackResource = IopPortMemUnpackResource;
    IopRootPortArbiter.ScoreRequirement = IopPortMemScoreRequirement;
 
    Status = ArbiterLibInitializeInstance(&IopRootPortArbiter,
                                          NULL,
                                          CmResourceTypePort,
                                          IopRootPortArbiter.Name,
                                          L"Root",
                                          NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbPortInitialize: Failed with %X", 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();
 
    /* Initialize arbiters */
    Status = IopInitializeArbiters();
    if (!NT_SUCCESS(Status)) return Status;
 
    /* 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().