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	IopPortInitialize (VOID)
NTSTATUS NTAPI	IopMemInitialize (VOID)
NTSTATUS NTAPI	IopDmaInitialize (VOID)
NTSTATUS NTAPI	IopIrqInitialize (VOID)
NTSTATUS NTAPI	IopBusNumberInitialize (VOID)
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

IopBusNumberInitialize()

NTSTATUS NTAPI IopBusNumberInitialize

(

VOID

)

Definition at line 90 of file arbiters.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    DPRINT("IopRootBusNumberArbiter %p\n", &IopRootBusNumberArbiter);
 
    IopRootBusNumberArbiter.UnpackRequirement = IopBusNumberUnpackRequirement;
    IopRootBusNumberArbiter.PackResource = IopBusNumberPackResource;
    IopRootBusNumberArbiter.UnpackResource = IopBusNumberUnpackResource;
    IopRootBusNumberArbiter.ScoreRequirement = IopBusNumberScoreRequirement;
 
    Status = ArbInitializeArbiterInstance(&IopRootBusNumberArbiter,
                                          NULL,
                                          CmResourceTypeBusNumber,
                                          L"RootBusNumber",
                                          L"Root",
                                          NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopBusNumberInitialize: Status %p\n", Status);
        ASSERT(FALSE);
        return Status;
    }
 
    Status = RtlAddRange(IopRootBusNumberArbiter.Allocation,
                         (UINT64)(ARB_MAX_BUS_NUMBER + 1),
                         (UINT64)(-1),
                         0,
                         0,
                         NULL,
                         NULL);
 
    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().

IopDmaInitialize()

NTSTATUS NTAPI IopDmaInitialize

(

VOID

)

Definition at line 296 of file arbiters.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    DPRINT("IopRootDmaArbiter %p\n", &IopRootDmaArbiter);
 
    IopRootDmaArbiter.UnpackRequirement = IopDmaUnpackRequirement;
    IopRootDmaArbiter.PackResource = IopDmaPackResource;
    IopRootDmaArbiter.UnpackResource = IopDmaUnpackResource;
    IopRootDmaArbiter.ScoreRequirement = IopDmaScoreRequirement;
 
    IopRootDmaArbiter.OverrideConflict = IopDmaOverrideConflict;
 
    Status = ArbInitializeArbiterInstance(&IopRootDmaArbiter,
                                          NULL,
                                          CmResourceTypeDma,
                                          L"RootDMA",
                                          L"Root",
                                          NULL);
    return Status;
}

Referenced by IopInitializeArbiters().

IopInitializeArbiters()

NTSTATUS NTAPI IopInitializeArbiters

(

VOID

)

Definition at line 49 of file pnpinit.c.

{
    NTSTATUS Status;
 
    Status = IopPortInitialize();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopPortInitialize() return %X\n", Status);
        return Status;
    }
 
    Status = IopMemInitialize();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopMemInitialize() return %X\n", Status);
        return Status;
    }
 
    Status = IopDmaInitialize();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopDmaInitialize() return %X\n", Status);
        return Status;
    }
 
    Status = IopIrqInitialize();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopIrqInitialize() return %X\n", Status);
        return Status;
    }
 
    Status = IopBusNumberInitialize();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopBusNumberInitialize() 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 */
    PnpBusTypeGuidList = ExAllocatePool(PagedPool, sizeof(IO_BUS_TYPE_GUID_LIST));
    RtlZeroMemory(PnpBusTypeGuidList, sizeof(IO_BUS_TYPE_GUID_LIST));
    ExInitializeFastMutex(&PnpBusTypeGuidList->Lock);
 
    /* 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().

IopIrqInitialize()

NTSTATUS NTAPI IopIrqInitialize

(

VOID

)

Definition at line 201 of file arbiters.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    DPRINT("IopRootIrqArbiter %p\n", &IopRootIrqArbiter);
 
    IopRootIrqArbiter.UnpackRequirement = IopIrqUnpackRequirement;
    IopRootIrqArbiter.PackResource = IopIrqPackResource;
    IopRootIrqArbiter.UnpackResource = IopIrqUnpackResource;
    IopRootIrqArbiter.ScoreRequirement = IopIrqScoreRequirement;
 
    Status = ArbInitializeArbiterInstance(&IopRootIrqArbiter,
                                          NULL,
                                          CmResourceTypeInterrupt,
                                          L"RootIRQ",
                                          L"Root",
                                          IopIrqTranslateOrdering);
    return Status;
}

Referenced by IopInitializeArbiters().

IopMemInitialize()

NTSTATUS NTAPI IopMemInitialize

(

VOID

)

Definition at line 409 of file arbiters.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    DPRINT("IopRootMemArbiter %p\n", &IopRootMemArbiter);
 
    IopRootMemArbiter.UnpackRequirement = IopGenericUnpackRequirement;
    IopRootMemArbiter.PackResource = IopGenericPackResource;
    IopRootMemArbiter.UnpackResource = IopGenericUnpackResource;
    IopRootMemArbiter.ScoreRequirement = IopGenericScoreRequirement;
 
    IopRootMemArbiter.FindSuitableRange = IopMemFindSuitableRange;
 
    Status = ArbInitializeArbiterInstance(&IopRootMemArbiter,
                                          NULL,
                                          CmResourceTypeMemory,
                                          L"RootMemory",
                                          L"Root",
                                          IopGenericTranslateOrdering);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopMemInitialize: Status %p\n", Status);
        ASSERT(FALSE);
        return Status;
    }
 
    Status = RtlAddRange(IopRootMemArbiter.Allocation,
                         0,
                         (UINT64)(PAGE_SIZE - 1),
                         0,
                         0,
                         NULL,
                         NULL);
 
    return Status;
}

Referenced by IopInitializeArbiters().

IopPortInitialize()

NTSTATUS NTAPI IopPortInitialize

(

VOID

)

Definition at line 490 of file arbiters.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    DPRINT("IopRootPortArbiter %p\n", &IopRootPortArbiter);
 
    IopRootPortArbiter.UnpackRequirement = IopGenericUnpackRequirement;
    IopRootPortArbiter.PackResource = IopGenericPackResource;
    IopRootPortArbiter.UnpackResource = IopGenericUnpackResource;
    IopRootPortArbiter.ScoreRequirement = IopGenericScoreRequirement;
 
    IopRootPortArbiter.FindSuitableRange = IopPortFindSuitableRange;
    IopRootPortArbiter.AddAllocation = IopPortAddAllocation;
    IopRootPortArbiter.BacktrackAllocation = IopPortBacktrackAllocation;
 
    Status = ArbInitializeArbiterInstance(&IopRootPortArbiter,
                                          NULL,
                                          CmResourceTypePort,
                                          L"RootPort",
                                          L"Root",
                                          IopGenericTranslateOrdering);
    return Status;
}

Referenced by IopInitializeArbiters().

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 IopBusNumberInitialize().

IopRootDmaArbiter

ARBITER_INSTANCE IopRootDmaArbiter

Definition at line 25 of file pnpinit.c.

Referenced by IopDmaInitialize().

IopRootIrqArbiter

ARBITER_INSTANCE IopRootIrqArbiter

Definition at line 24 of file pnpinit.c.

Referenced by IopIrqInitialize().

IopRootMemArbiter

ARBITER_INSTANCE IopRootMemArbiter

Definition at line 26 of file pnpinit.c.

Referenced by IopMemInitialize().

IopRootPortArbiter

ARBITER_INSTANCE IopRootPortArbiter

Definition at line 27 of file pnpinit.c.

Referenced by IopPortInitialize().

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().