plugplay.c File Reference

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

Include dependency graph for plugplay.c:

Go to the source code of this file.

Classes
struct	_PNP_EVENT_ENTRY
struct	_IOP_FIND_DEVICE_INSTANCE_TRAVERSE_CONTEXT

Macros
#define	NDEBUG

Typedefs
typedef struct _PNP_EVENT_ENTRY	PNP_EVENT_ENTRY
typedef struct _PNP_EVENT_ENTRY *	PPNP_EVENT_ENTRY
typedef struct _IOP_FIND_DEVICE_INSTANCE_TRAVERSE_CONTEXT	IOP_FIND_DEVICE_INSTANCE_TRAVERSE_CONTEXT
typedef struct _IOP_FIND_DEVICE_INSTANCE_TRAVERSE_CONTEXT *	PIOP_FIND_DEVICE_INSTANCE_TRAVERSE_CONTEXT

Functions
NTSTATUS	IopSetDeviceInstanceData (HANDLE InstanceKey, PDEVICE_NODE DeviceNode)
NTSTATUS	IopInitPlugPlayEvents (VOID)
NTSTATUS	IopQueueDeviceChangeEvent (_In_ const GUID *EventGuid, _In_ const GUID *InterfaceClassGuid, _In_ PUNICODE_STRING SymbolicLinkName)
NTSTATUS	IopQueueDeviceInstallEvent (_In_ const GUID *EventGuid, _In_ PUNICODE_STRING DeviceId)
NTSTATUS	IopQueueDevicePropertyChangeEvent (_In_ PCUNICODE_STRING DeviceId)
NTSTATUS	IopQueueTargetDeviceEvent (const GUID *Guid, PUNICODE_STRING DeviceIds)
NTSTATUS	IopFindDeviceInstanceTraverse (_In_ PDEVICE_NODE DeviceNode, _Inout_ PVOID Context)
PDEVICE_OBJECT	IopGetDeviceObjectFromDeviceInstance (PUNICODE_STRING DeviceInstance)
static NTSTATUS	IopCaptureUnicodeString (PUNICODE_STRING DstName, PUNICODE_STRING SrcName)
static NTSTATUS	PiControlInitializeDevice (_In_ PPLUGPLAY_CONTROL_DEVICE_CONTROL_DATA ControlData)
static NTSTATUS	IopRemovePlugPlayEvent (_In_ PPLUGPLAY_CONTROL_USER_RESPONSE_DATA ResponseData)
static NTSTATUS	IopGetInterfaceDeviceList (PPLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA DeviceList)
static NTSTATUS	IopGetDeviceProperty (PPLUGPLAY_CONTROL_PROPERTY_DATA PropertyData)
static NTSTATUS	IopGetRelatedDevice (PPLUGPLAY_CONTROL_RELATED_DEVICE_DATA RelatedDeviceData)
static BOOLEAN	PiIsDevNodeStarted (_In_ PDEVICE_NODE DeviceNode)
ULONG	IopGetDeviceNodeStatus (_In_ PDEVICE_NODE DeviceNode)
static NTSTATUS	IopDeviceStatus (PPLUGPLAY_CONTROL_STATUS_DATA StatusData)
static NTSTATUS	IopGetDeviceRelations (PPLUGPLAY_CONTROL_DEVICE_RELATIONS_DATA RelationsData)
static NTSTATUS	IopGetDeviceDepth (PPLUGPLAY_CONTROL_DEPTH_DATA DepthData)
static NTSTATUS	PiControlSyncDeviceAction (_In_ PPLUGPLAY_CONTROL_DEVICE_CONTROL_DATA DeviceData, _In_ PLUGPLAY_CONTROL_CLASS ControlClass)
static NTSTATUS	PiControlQueryRemoveDevice (_In_ PPLUGPLAY_CONTROL_QUERY_REMOVE_DATA ControlData)
static NTSTATUS	PiControlGetInterfaceDeviceAlias (_In_ PPLUGPLAY_CONTROL_INTERFACE_ALIAS_DATA ControlData)
static NTSTATUS	PiControlDeviceClassAssociation (_In_ PPLUGPLAY_CONTROL_CLASS_ASSOCIATION_DATA ControlData)
NTSTATUS NTAPI	NtGetPlugPlayEvent (IN ULONG Reserved1, IN ULONG Reserved2, OUT PPLUGPLAY_EVENT_BLOCK Buffer, IN ULONG BufferSize)
NTSTATUS NTAPI	NtPlugPlayControl (IN PLUGPLAY_CONTROL_CLASS PlugPlayControlClass, IN OUT PVOID Buffer, IN ULONG BufferLength)

Variables
static LIST_ENTRY	IopPnpEventQueueHead
static KEVENT	IopPnpNotifyEvent

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file plugplay.c.

Typedef Documentation

IOP_FIND_DEVICE_INSTANCE_TRAVERSE_CONTEXT

typedef struct _IOP_FIND_DEVICE_INSTANCE_TRAVERSE_CONTEXT IOP_FIND_DEVICE_INSTANCE_TRAVERSE_CONTEXT

PIOP_FIND_DEVICE_INSTANCE_TRAVERSE_CONTEXT

typedef struct _IOP_FIND_DEVICE_INSTANCE_TRAVERSE_CONTEXT * PIOP_FIND_DEVICE_INSTANCE_TRAVERSE_CONTEXT

PNP_EVENT_ENTRY

typedef struct _PNP_EVENT_ENTRY PNP_EVENT_ENTRY

PPNP_EVENT_ENTRY

typedef struct _PNP_EVENT_ENTRY * PPNP_EVENT_ENTRY

Function Documentation

IopCaptureUnicodeString()

static NTSTATUS IopCaptureUnicodeString ( PUNICODE_STRING  DstName, PUNICODE_STRING  SrcName  )

static

Definition at line 268 of file plugplay.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    volatile UNICODE_STRING Name;
 
    Name.Buffer = NULL;
    _SEH2_TRY
    {
        Name.Length = SrcName->Length;
        Name.MaximumLength = SrcName->MaximumLength;
        if (Name.Length > Name.MaximumLength)
        {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        if (Name.MaximumLength)
        {
            ProbeForRead(SrcName->Buffer,
                         Name.MaximumLength,
                         sizeof(WCHAR));
            Name.Buffer = ExAllocatePool(NonPagedPool, Name.MaximumLength);
            if (Name.Buffer == NULL)
            {
                Status = STATUS_INSUFFICIENT_RESOURCES;
                _SEH2_LEAVE;
            }
 
            memcpy(Name.Buffer, SrcName->Buffer, Name.MaximumLength);
        }
 
        *DstName = Name;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        if (Name.Buffer)
        {
            ExFreePool(Name.Buffer);
        }
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;
 
    return Status;
}

Referenced by IopDeviceStatus(), IopGetDeviceDepth(), IopGetDeviceProperty(), IopGetDeviceRelations(), IopGetInterfaceDeviceList(), IopGetRelatedDevice(), PiControlInitializeDevice(), PiControlQueryRemoveDevice(), and PiControlSyncDeviceAction().

IopDeviceStatus()

static NTSTATUS IopDeviceStatus ( PPLUGPLAY_CONTROL_STATUS_DATA  StatusData )

static

Definition at line 951 of file plugplay.c.

{
    PDEVICE_OBJECT DeviceObject;
    PDEVICE_NODE DeviceNode;
    ULONG Operation = 0;
    ULONG DeviceStatus = 0;
    ULONG DeviceProblem = 0;
    UNICODE_STRING DeviceInstance;
    NTSTATUS Status;
 
    DPRINT("IopDeviceStatus() called\n");
 
    Status = IopCaptureUnicodeString(&DeviceInstance, &StatusData->DeviceInstance);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    DPRINT("Device name: '%wZ'\n", &DeviceInstance);
 
    _SEH2_TRY
    {
        Operation = StatusData->Operation;
        if (Operation == PNP_SET_DEVICE_STATUS)
        {
            DeviceStatus = StatusData->DeviceStatus;
            DeviceProblem = StatusData->DeviceProblem;
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        if (DeviceInstance.Buffer != NULL)
        {
            ExFreePool(DeviceInstance.Buffer);
        }
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    /* Get the device object */
    DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
    if (DeviceInstance.Buffer != NULL)
    {
        ExFreePool(DeviceInstance.Buffer);
    }
    if (DeviceObject == NULL)
    {
        return STATUS_NO_SUCH_DEVICE;
    }
 
    DeviceNode = IopGetDeviceNode(DeviceObject);
 
    switch (Operation)
    {
        case PNP_GET_DEVICE_STATUS:
            DPRINT("Get status data\n");
            DeviceStatus = IopGetDeviceNodeStatus(DeviceNode);
            DeviceProblem = DeviceNode->Problem;
            break;
 
        case PNP_SET_DEVICE_STATUS:
            DPRINT1("Set status data is NOT SUPPORTED\n");
            break;
 
        case PNP_CLEAR_DEVICE_STATUS:
            DPRINT1("FIXME: Clear status data!\n");
            break;
    }
 
    ObDereferenceObject(DeviceObject);
 
    if (Operation == PNP_GET_DEVICE_STATUS)
    {
        _SEH2_TRY
        {
            StatusData->DeviceStatus = DeviceStatus;
            StatusData->DeviceProblem = DeviceProblem;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
    }
 
    return Status;
}

Referenced by NtPlugPlayControl().

IopFindDeviceInstanceTraverse()

NTSTATUS IopFindDeviceInstanceTraverse	(	_In_ PDEVICE_NODE	DeviceNode,
		_Inout_ PVOID	Context
	)

Definition at line 214 of file plugplay.c.

{
    PIOP_FIND_DEVICE_INSTANCE_TRAVERSE_CONTEXT DeviceInstanceContext = Context;
 
    if (RtlEqualUnicodeString(&DeviceNode->InstancePath,
                              DeviceInstanceContext->InstancePath, TRUE))
    {
        ObReferenceObject(DeviceNode->PhysicalDeviceObject);
        DeviceInstanceContext->DeviceObject = DeviceNode->PhysicalDeviceObject;
 
        /* Stop enumeration */
        return STATUS_UNSUCCESSFUL;
    }
 
    return STATUS_SUCCESS;
}

Referenced by IopGetDeviceObjectFromDeviceInstance().

IopGetDeviceDepth()

static NTSTATUS IopGetDeviceDepth ( PPLUGPLAY_CONTROL_DEPTH_DATA  DepthData )

static

Definition at line 1198 of file plugplay.c.

{
    PDEVICE_OBJECT DeviceObject;
    PDEVICE_NODE DeviceNode;
    UNICODE_STRING DeviceInstance;
    NTSTATUS Status = STATUS_SUCCESS;
 
    DPRINT("IopGetDeviceDepth() called\n");
    DPRINT("Device name: %wZ\n", &DepthData->DeviceInstance);
 
    Status = IopCaptureUnicodeString(&DeviceInstance, &DepthData->DeviceInstance);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Get the device object */
    DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
    if (DeviceInstance.Buffer != NULL)
    {
        ExFreePool(DeviceInstance.Buffer);
    }
    if (DeviceObject == NULL)
    {
        return STATUS_NO_SUCH_DEVICE;
    }
 
    DeviceNode = IopGetDeviceNode(DeviceObject);
 
    _SEH2_TRY
    {
        DepthData->Depth = DeviceNode->Level;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;
 
    ObDereferenceObject(DeviceObject);
 
    return Status;
}

Referenced by NtPlugPlayControl().

IopGetDeviceNodeStatus()

ULONG IopGetDeviceNodeStatus

(

_In_ PDEVICE_NODE

DeviceNode

)

Definition at line 905 of file plugplay.c.

{
    ULONG Output = DN_NT_ENUMERATOR | DN_NT_DRIVER;
 
    if (DeviceNode->Parent == IopRootDeviceNode)
        Output |= DN_ROOT_ENUMERATED;
 
    // FIXME: review for deleted and removed states
    if (DeviceNode->State >= DeviceNodeDriversAdded)
        Output |= DN_DRIVER_LOADED;
 
    if (PiIsDevNodeStarted(DeviceNode))
        Output |= DN_STARTED;
 
    if (DeviceNode->UserFlags & DNUF_WILL_BE_REMOVED)
        Output |= DN_WILL_BE_REMOVED;
 
    if (DeviceNode->Flags & DNF_HAS_PROBLEM)
        Output |= DN_HAS_PROBLEM;
 
    if (DeviceNode->Flags & DNF_HAS_PRIVATE_PROBLEM)
        Output |= DN_PRIVATE_PROBLEM;
 
    if (DeviceNode->Flags & DNF_DRIVER_BLOCKED)
        Output |= DN_DRIVER_BLOCKED;
 
    if (DeviceNode->Flags & DNF_CHILD_WITH_INVALID_ID)
        Output |= DN_CHILD_WITH_INVALID_ID;
 
    if (DeviceNode->Flags & DNF_HAS_PRIVATE_PROBLEM)
        Output |= DN_PRIVATE_PROBLEM;
 
    if (DeviceNode->Flags & DNF_LEGACY_DRIVER)
        Output |= DN_LEGACY_DRIVER;
 
    if (DeviceNode->UserFlags & DNUF_DONT_SHOW_IN_UI)
        Output |= DN_NO_SHOW_IN_DM;
 
    if (!(DeviceNode->UserFlags & DNUF_NOT_DISABLEABLE))
        Output |= DN_DISABLEABLE;
 
    return Output;
}

Referenced by IopDeviceStatus(), and PiPropReadDeviceNodeField().

IopGetDeviceObjectFromDeviceInstance()

PDEVICE_OBJECT IopGetDeviceObjectFromDeviceInstance

(

PUNICODE_STRING

DeviceInstance

)

Definition at line 234 of file plugplay.c.

{
    DEVICETREE_TRAVERSE_CONTEXT Context;
    IOP_FIND_DEVICE_INSTANCE_TRAVERSE_CONTEXT DeviceInstanceContext;
 
    if (IopRootDeviceNode == NULL)
        return NULL;
 
    if (DeviceInstance == NULL ||
        DeviceInstance->Length == 0)
    {
        if (IopRootDeviceNode->PhysicalDeviceObject)
        {
            ObReferenceObject(IopRootDeviceNode->PhysicalDeviceObject);
            return IopRootDeviceNode->PhysicalDeviceObject;
        }
        else
            return NULL;
    }
 
    /* Traverse the device tree to find the matching device node */
    DeviceInstanceContext.InstancePath = DeviceInstance;
    DeviceInstanceContext.DeviceObject = NULL;
    IopInitDeviceTreeTraverseContext(&Context,
                                     IopRootDeviceNode,
                                     IopFindDeviceInstanceTraverse,
                                     &DeviceInstanceContext);
    (void)IopTraverseDeviceTree(&Context);
 
    /* In case of error or instance not found, this will still be NULL from above. */
    return DeviceInstanceContext.DeviceObject;
}

Referenced by IopDeviceStatus(), IopGetDeviceDepth(), IopGetDeviceProperty(), IopGetDeviceRelations(), IopGetInterfaceDeviceList(), IopGetRelatedDevice(), IopInitializeBuiltinDriver(), IoSetDeviceInterfaceState(), PiControlDeviceClassAssociation(), PiControlInitializeDevice(), PiControlQueryRemoveDevice(), PiControlSyncDeviceAction(), and PiInitializeDevNode().

IopGetDeviceProperty()

static NTSTATUS IopGetDeviceProperty ( PPLUGPLAY_CONTROL_PROPERTY_DATA  PropertyData )

static

Definition at line 519 of file plugplay.c.

{
    PDEVICE_OBJECT DeviceObject = NULL;
    PDEVICE_NODE DeviceNode;
    UNICODE_STRING DeviceInstance;
    ULONG BufferSize;
    ULONG Property;
    DEVICE_REGISTRY_PROPERTY DeviceProperty;
    PVOID Buffer;
    NTSTATUS Status;
 
    DPRINT("IopGetDeviceProperty() called\n");
    DPRINT("Device name: %wZ\n", &PropertyData->DeviceInstance);
 
    Status = IopCaptureUnicodeString(&DeviceInstance, &PropertyData->DeviceInstance);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    _SEH2_TRY
    {
        Property = PropertyData->Property;
        BufferSize = PropertyData->BufferSize;
        ProbeForWrite(PropertyData->Buffer,
                      BufferSize,
                      sizeof(UCHAR));
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        if (DeviceInstance.Buffer != NULL)
        {
            ExFreePool(DeviceInstance.Buffer);
        }
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    /* Get the device object */
    DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
    if (DeviceInstance.Buffer != NULL)
    {
        ExFreePool(DeviceInstance.Buffer);
    }
    if (DeviceObject == NULL)
    {
        return STATUS_NO_SUCH_DEVICE;
    }
 
    Buffer = ExAllocatePool(NonPagedPool, BufferSize);
    if (Buffer == NULL)
    {
        ObDereferenceObject(DeviceObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
 
    DeviceNode = IoGetDevObjExtension(DeviceObject)->DeviceNode;
 
    if (Property == PNP_PROPERTY_POWER_DATA)
    {
        if (BufferSize < sizeof(CM_POWER_DATA))
        {
            BufferSize = 0;
            Status = STATUS_BUFFER_TOO_SMALL;
        }
        else
        {
            DEVICE_CAPABILITIES DeviceCapabilities;
            PCM_POWER_DATA PowerData;
            IO_STACK_LOCATION Stack;
            IO_STATUS_BLOCK IoStatusBlock;
 
            PowerData = (PCM_POWER_DATA)Buffer;
            RtlZeroMemory(PowerData, sizeof(CM_POWER_DATA));
            PowerData->PD_Size = sizeof(CM_POWER_DATA);
 
            RtlZeroMemory(&DeviceCapabilities, sizeof(DEVICE_CAPABILITIES));
            DeviceCapabilities.Size = sizeof(DEVICE_CAPABILITIES);
            DeviceCapabilities.Version = 1;
            DeviceCapabilities.Address = -1;
            DeviceCapabilities.UINumber = -1;
 
            Stack.Parameters.DeviceCapabilities.Capabilities = &DeviceCapabilities;
 
            Status = IopInitiatePnpIrp(DeviceObject,
                                       &IoStatusBlock,
                                       IRP_MN_QUERY_CAPABILITIES,
                                       &Stack);
            if (NT_SUCCESS(Status))
            {
                DPRINT("Got device capabiliities\n");
 
                PowerData->PD_MostRecentPowerState = PowerDeviceD0; // FIXME
                if (DeviceCapabilities.DeviceD1)
                    PowerData->PD_Capabilities |= PDCAP_D1_SUPPORTED;
                if (DeviceCapabilities.DeviceD2)
                    PowerData->PD_Capabilities |= PDCAP_D2_SUPPORTED;
                if (DeviceCapabilities.WakeFromD0)
                    PowerData->PD_Capabilities |= PDCAP_WAKE_FROM_D0_SUPPORTED;
                if (DeviceCapabilities.WakeFromD1)
                    PowerData->PD_Capabilities |= PDCAP_WAKE_FROM_D1_SUPPORTED;
                if (DeviceCapabilities.WakeFromD2)
                    PowerData->PD_Capabilities |= PDCAP_WAKE_FROM_D2_SUPPORTED;
                if (DeviceCapabilities.WakeFromD3)
                    PowerData->PD_Capabilities |= PDCAP_WAKE_FROM_D3_SUPPORTED;
                if (DeviceCapabilities.WarmEjectSupported)
                    PowerData->PD_Capabilities |= PDCAP_WARM_EJECT_SUPPORTED;
                PowerData->PD_D1Latency = DeviceCapabilities.D1Latency;
                PowerData->PD_D2Latency = DeviceCapabilities.D2Latency;
                PowerData->PD_D3Latency = DeviceCapabilities.D3Latency;
                RtlCopyMemory(&PowerData->PD_PowerStateMapping,
                              &DeviceCapabilities.DeviceState,
                              sizeof(DeviceCapabilities.DeviceState));
                PowerData->PD_DeepestSystemWake = DeviceCapabilities.SystemWake;
            }
            else
            {
                DPRINT("IRP_MN_QUERY_CAPABILITIES failed (Status 0x%08lx)\n", Status);
 
                PowerData->PD_Capabilities = PDCAP_D0_SUPPORTED | PDCAP_D3_SUPPORTED;
                PowerData->PD_MostRecentPowerState = PowerDeviceD0;
            }
        }
    }
    else if (Property == PNP_PROPERTY_REMOVAL_POLICY_OVERRIDE)
    {
        UNIMPLEMENTED;
        BufferSize = 0;
        Status = STATUS_NOT_IMPLEMENTED;
    }
    else if (Property == PNP_PROPERTY_REMOVAL_POLICY_HARDWARE_DEFAULT)
    {
        if (BufferSize < sizeof(DeviceNode->HardwareRemovalPolicy))
        {
            BufferSize = 0;
            Status = STATUS_BUFFER_TOO_SMALL;
        }
        else
        {
            BufferSize = sizeof(DeviceNode->HardwareRemovalPolicy);
            RtlCopyMemory(Buffer,
                          &DeviceNode->HardwareRemovalPolicy,
                          BufferSize);
        }
    }
#if (WINVER >= _WIN32_WINNT_WS03)
    else if (Property == PNP_PROPERTY_LOCATION_PATHS)
    {
        UNIMPLEMENTED;
        BufferSize = 0;
        Status = STATUS_NOT_IMPLEMENTED;
    }
#endif
    else
    {
        switch (Property)
        {
            case PNP_PROPERTY_UI_NUMBER:
                DeviceProperty = DevicePropertyUINumber;
                break;
 
            case PNP_PROPERTY_PHYSICAL_DEVICE_OBJECT_NAME:
                DeviceProperty = DevicePropertyPhysicalDeviceObjectName;
                break;
 
            case PNP_PROPERTY_BUSTYPEGUID:
                DeviceProperty = DevicePropertyBusTypeGuid;
                break;
 
            case PNP_PROPERTY_LEGACYBUSTYPE:
                DeviceProperty = DevicePropertyLegacyBusType;
                break;
 
            case PNP_PROPERTY_BUSNUMBER:
                DeviceProperty = DevicePropertyBusNumber;
                break;
 
            case PNP_PROPERTY_REMOVAL_POLICY:
                DeviceProperty = DevicePropertyRemovalPolicy;
                break;
 
            case PNP_PROPERTY_ADDRESS:
                DeviceProperty = DevicePropertyAddress;
                break;
 
            case PNP_PROPERTY_ENUMERATOR_NAME:
                DeviceProperty = DevicePropertyEnumeratorName;
                break;
 
            case PNP_PROPERTY_INSTALL_STATE:
                DeviceProperty = DevicePropertyInstallState;
                break;
 
#if (WINVER >= _WIN32_WINNT_WIN7)
            case PNP_PROPERTY_CONTAINERID:
                DeviceProperty = DevicePropertyContainerID;
                break;
#endif
 
            default:
                BufferSize = 0;
                Status = STATUS_INVALID_PARAMETER;
                break;
        }
 
        if (Status == STATUS_SUCCESS)
        {
            Status = IoGetDeviceProperty(DeviceObject,
                                         DeviceProperty,
                                         BufferSize,
                                         Buffer,
                                         &BufferSize);
        }
    }
 
    ObDereferenceObject(DeviceObject);
 
    if (NT_SUCCESS(Status))
    {
        _SEH2_TRY
        {
            RtlCopyMemory(PropertyData->Buffer, Buffer, BufferSize);
            PropertyData->BufferSize = BufferSize;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
    }
 
    ExFreePool(Buffer);
    return Status;
}

Referenced by NtPlugPlayControl().

IopGetDeviceRelations()

static NTSTATUS IopGetDeviceRelations ( PPLUGPLAY_CONTROL_DEVICE_RELATIONS_DATA  RelationsData )

static

Definition at line 1041 of file plugplay.c.

{
    UNICODE_STRING DeviceInstance;
    PDEVICE_OBJECT DeviceObject = NULL;
    IO_STACK_LOCATION Stack;
    IO_STATUS_BLOCK IoStatusBlock;
    PDEVICE_RELATIONS DeviceRelations = NULL;
    PDEVICE_OBJECT ChildDeviceObject;
    PDEVICE_NODE ChildDeviceNode;
    ULONG i;
    ULONG Relations;
    ULONG BufferSize, RequiredSize;
    ULONG BufferLeft;
    PWCHAR Buffer, Ptr;
    NTSTATUS Status = STATUS_SUCCESS;
 
    DPRINT1("IopGetDeviceRelations() called\n");
    DPRINT1("Device name: %wZ\n", &RelationsData->DeviceInstance);
    DPRINT("Relations: %lu\n", RelationsData->Relations);
    DPRINT("BufferSize: %lu\n", RelationsData->BufferSize);
    DPRINT("Buffer: %p\n", RelationsData->Buffer);
 
    _SEH2_TRY
    {
        Relations = RelationsData->Relations;
        BufferSize = RelationsData->BufferSize;
        Buffer = RelationsData->Buffer;
 
        ProbeForWrite(Buffer, BufferSize, sizeof(CHAR));
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    Status = IopCaptureUnicodeString(&DeviceInstance, &RelationsData->DeviceInstance);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopCaptureUnicodeString() failed (Status 0x%08lx)\n", Status);
        return Status;
    }
 
    /* Get the device object */
    DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
    if (DeviceObject == NULL)
    {
        DPRINT1("IopGetDeviceObjectFromDeviceInstance() returned NULL\n");
        Status = STATUS_NO_SUCH_DEVICE;
        goto done;
    }
 
    switch (Relations)
    {
        case PNP_EJECT_RELATIONS:
            Stack.Parameters.QueryDeviceRelations.Type = EjectionRelations;
            break;
 
        case PNP_REMOVAL_RELATIONS:
            Stack.Parameters.QueryDeviceRelations.Type = RemovalRelations;
            break;
 
        case PNP_POWER_RELATIONS:
            Stack.Parameters.QueryDeviceRelations.Type = PowerRelations;
            break;
 
        case PNP_BUS_RELATIONS:
            Stack.Parameters.QueryDeviceRelations.Type = BusRelations;
            break;
 
        default:
            Status = STATUS_INVALID_PARAMETER;
            goto done;
    }
 
    Status = IopInitiatePnpIrp(DeviceObject,
                               &IoStatusBlock,
                               IRP_MN_QUERY_DEVICE_RELATIONS,
                               &Stack);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopInitiatePnpIrp() failed (Status 0x%08lx)\n", Status);
        goto done;
    }
 
    DeviceRelations = (PDEVICE_RELATIONS)IoStatusBlock.Information;
 
    DPRINT1("Found %d device relations\n", DeviceRelations->Count);
 
    _SEH2_TRY
    {
        RequiredSize = 0;
        BufferLeft = BufferSize;
        Ptr = Buffer;
 
        for (i = 0; i < DeviceRelations->Count; i++)
        {
            ChildDeviceObject = DeviceRelations->Objects[i];
 
            ChildDeviceNode = IopGetDeviceNode(ChildDeviceObject);
            if (ChildDeviceNode)
            {
                DPRINT("Device instance: %wZ\n", &ChildDeviceNode->InstancePath);
                DPRINT("RequiredSize: %hu\n", ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
 
                if (Ptr != NULL)
                {
                    if (BufferLeft < ChildDeviceNode->InstancePath.Length + 2 * sizeof(WCHAR))
                    {
                        Status = STATUS_BUFFER_TOO_SMALL;
                        break;
                    }
 
                    RtlCopyMemory(Ptr,
                                  ChildDeviceNode->InstancePath.Buffer,
                                  ChildDeviceNode->InstancePath.Length);
                    Ptr = (PWCHAR)((ULONG_PTR)Ptr + ChildDeviceNode->InstancePath.Length);
                    *Ptr = UNICODE_NULL;
                    Ptr = (PWCHAR)((ULONG_PTR)Ptr + sizeof(WCHAR));
 
                    BufferLeft -= (ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
                }
 
                RequiredSize += (ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
            }
        }
 
        if (Ptr != NULL && BufferLeft >= sizeof(WCHAR))
            *Ptr = UNICODE_NULL;
 
        if (RequiredSize > 0)
            RequiredSize += sizeof(WCHAR);
 
        DPRINT("BufferSize: %lu  RequiredSize: %lu\n", RelationsData->BufferSize, RequiredSize);
 
        RelationsData->BufferSize = RequiredSize;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;
 
done:
    if (DeviceRelations != NULL)
        ExFreePool(DeviceRelations);
 
    if (DeviceObject != NULL)
        ObDereferenceObject(DeviceObject);
 
    if (DeviceInstance.Buffer != NULL)
        ExFreePool(DeviceInstance.Buffer);
 
    return Status;
}

Referenced by NtPlugPlayControl().

IopGetInterfaceDeviceList()

static NTSTATUS IopGetInterfaceDeviceList ( PPLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA  DeviceList )

static

Definition at line 441 of file plugplay.c.

{
    NTSTATUS Status;
    PLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA StackList;
    UNICODE_STRING DeviceInstance;
    PDEVICE_OBJECT DeviceObject = NULL;
    GUID FilterGuid;
    PZZWSTR SymbolicLinkList = NULL, LinkList;
    SIZE_T TotalLength;
 
    _SEH2_TRY
    {
        RtlCopyMemory(&StackList, DeviceList, sizeof(PLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA));
 
        ProbeForRead(StackList.FilterGuid, sizeof(GUID), sizeof(UCHAR));
        RtlCopyMemory(&FilterGuid, StackList.FilterGuid, sizeof(GUID));
 
        if (StackList.Buffer != NULL && StackList.BufferSize != 0)
        {
            ProbeForWrite(StackList.Buffer, StackList.BufferSize, sizeof(UCHAR));
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    Status = IopCaptureUnicodeString(&DeviceInstance, &StackList.DeviceInstance);
    if (NT_SUCCESS(Status))
    {
        /* Get the device object */
        DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
        if (DeviceInstance.Buffer != NULL)
        {
            ExFreePool(DeviceInstance.Buffer);
        }
    }
 
    Status = IoGetDeviceInterfaces(&FilterGuid, DeviceObject, StackList.Flags, &SymbolicLinkList);
    ObDereferenceObject(DeviceObject);
 
    if (!NT_SUCCESS(Status))
    {
        /* failed */
        return Status;
    }
 
    LinkList = SymbolicLinkList;
    while (*SymbolicLinkList != UNICODE_NULL)
    {
        SymbolicLinkList += wcslen(SymbolicLinkList) + (sizeof(UNICODE_NULL) / sizeof(WCHAR));
    }
    TotalLength = ((SymbolicLinkList - LinkList + 1) * sizeof(WCHAR));
 
    _SEH2_TRY
    {
        if (StackList.Buffer != NULL &&
            StackList.BufferSize >= TotalLength)
        {
            // We've already probed the buffer for writing above.
            RtlCopyMemory(StackList.Buffer, LinkList, TotalLength);
        }
 
        DeviceList->BufferSize = TotalLength;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ExFreePool(LinkList);
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    ExFreePool(LinkList);
    return STATUS_SUCCESS;
}

Referenced by NtPlugPlayControl().

IopGetRelatedDevice()

static NTSTATUS IopGetRelatedDevice ( PPLUGPLAY_CONTROL_RELATED_DEVICE_DATA  RelatedDeviceData )

static

Definition at line 757 of file plugplay.c.

{
    UNICODE_STRING RootDeviceName;
    PDEVICE_OBJECT DeviceObject = NULL;
    PDEVICE_NODE DeviceNode = NULL;
    PDEVICE_NODE RelatedDeviceNode;
    UNICODE_STRING TargetDeviceInstance;
    NTSTATUS Status = STATUS_SUCCESS;
    ULONG Relation = 0;
    ULONG MaximumLength = 0;
 
    DPRINT("IopGetRelatedDevice() called\n");
    DPRINT("Device name: %wZ\n", &RelatedDeviceData->TargetDeviceInstance);
 
    Status = IopCaptureUnicodeString(&TargetDeviceInstance, &RelatedDeviceData->TargetDeviceInstance);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    _SEH2_TRY
    {
        Relation = RelatedDeviceData->Relation;
        MaximumLength = RelatedDeviceData->RelatedDeviceInstanceLength;
        ProbeForWrite(RelatedDeviceData->RelatedDeviceInstance,
                      MaximumLength,
                      sizeof(WCHAR));
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        if (TargetDeviceInstance.Buffer != NULL)
        {
            ExFreePool(TargetDeviceInstance.Buffer);
        }
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    RtlInitUnicodeString(&RootDeviceName,
                         L"HTREE\\ROOT\\0");
    if (RtlEqualUnicodeString(&TargetDeviceInstance,
                              &RootDeviceName,
                              TRUE))
    {
        DeviceNode = IopRootDeviceNode;
        if (TargetDeviceInstance.Buffer != NULL)
        {
            ExFreePool(TargetDeviceInstance.Buffer);
        }
    }
    else
    {
        /* Get the device object */
        DeviceObject = IopGetDeviceObjectFromDeviceInstance(&TargetDeviceInstance);
        if (TargetDeviceInstance.Buffer != NULL)
        {
            ExFreePool(TargetDeviceInstance.Buffer);
        }
        if (DeviceObject == NULL)
            return STATUS_NO_SUCH_DEVICE;
 
        DeviceNode = IoGetDevObjExtension(DeviceObject)->DeviceNode;
    }
 
    switch (Relation)
    {
        case PNP_GET_PARENT_DEVICE:
            RelatedDeviceNode = DeviceNode->Parent;
            break;
 
        case PNP_GET_CHILD_DEVICE:
            RelatedDeviceNode = DeviceNode->Child;
            break;
 
        case PNP_GET_SIBLING_DEVICE:
            RelatedDeviceNode = DeviceNode->Sibling;
            break;
 
        default:
            if (DeviceObject != NULL)
            {
                ObDereferenceObject(DeviceObject);
            }
 
            return STATUS_INVALID_PARAMETER;
    }
 
    if (RelatedDeviceNode == NULL)
    {
        if (DeviceObject)
        {
            ObDereferenceObject(DeviceObject);
        }
 
        return STATUS_NO_SUCH_DEVICE;
    }
 
    if (RelatedDeviceNode->InstancePath.Length > MaximumLength)
    {
        if (DeviceObject)
        {
            ObDereferenceObject(DeviceObject);
        }
 
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    /* Copy related device instance name */
    _SEH2_TRY
    {
        RtlCopyMemory(RelatedDeviceData->RelatedDeviceInstance,
                      RelatedDeviceNode->InstancePath.Buffer,
                      RelatedDeviceNode->InstancePath.Length);
        RelatedDeviceData->RelatedDeviceInstanceLength = RelatedDeviceNode->InstancePath.Length;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;
 
    if (DeviceObject != NULL)
    {
        ObDereferenceObject(DeviceObject);
    }
 
    DPRINT("IopGetRelatedDevice() done\n");
 
    return Status;
}

Referenced by NtPlugPlayControl().

IopInitPlugPlayEvents()

NTSTATUS IopInitPlugPlayEvents

(

VOID

)

Definition at line 40 of file plugplay.c.

{
    InitializeListHead(&IopPnpEventQueueHead);
 
    KeInitializeEvent(&IopPnpNotifyEvent,
                      SynchronizationEvent,
                      FALSE);
 
    return STATUS_SUCCESS;
}

Referenced by IopInitializePlugPlayServices().

IopQueueDeviceChangeEvent()

NTSTATUS IopQueueDeviceChangeEvent	(	_In_ const GUID *	EventGuid,
		_In_ const GUID *	InterfaceClassGuid,
		_In_ PUNICODE_STRING	SymbolicLinkName
	)

Definition at line 52 of file plugplay.c.

{
    PPNP_EVENT_ENTRY EventEntry;
    UNICODE_STRING Copy;
    ULONG TotalSize;
 
    /* Allocate a big enough buffer */
    Copy.Length = 0;
    Copy.MaximumLength = SymbolicLinkName->Length + sizeof(UNICODE_NULL);
    TotalSize =
        FIELD_OFFSET(PLUGPLAY_EVENT_BLOCK, DeviceClass.SymbolicLinkName) +
        Copy.MaximumLength;
 
    EventEntry = ExAllocatePool(NonPagedPool,
                                TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
    if (!EventEntry)
        return STATUS_INSUFFICIENT_RESOURCES;
    RtlZeroMemory(EventEntry, TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
 
    /* Fill the buffer with the event GUID */
    RtlCopyMemory(&EventEntry->Event.EventGuid, EventGuid, sizeof(GUID));
    EventEntry->Event.EventCategory = DeviceClassChangeEvent;
    EventEntry->Event.TotalSize = TotalSize;
 
    /* Fill the interface class GUID */
    RtlCopyMemory(&EventEntry->Event.DeviceClass.ClassGuid, InterfaceClassGuid, sizeof(GUID));
 
    /* Fill the symbolic link name */
    RtlCopyMemory(&EventEntry->Event.DeviceClass.SymbolicLinkName,
                  SymbolicLinkName->Buffer, SymbolicLinkName->Length);
    EventEntry->Event.DeviceClass.SymbolicLinkName[SymbolicLinkName->Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    InsertHeadList(&IopPnpEventQueueHead,
                   &EventEntry->ListEntry);
    KeSetEvent(&IopPnpNotifyEvent,
               0,
               FALSE);
 
    return STATUS_SUCCESS;
}

Referenced by IoSetDeviceInterfaceState().

IopQueueDeviceInstallEvent()

NTSTATUS IopQueueDeviceInstallEvent	(	_In_ const GUID *	EventGuid,
		_In_ PUNICODE_STRING	DeviceId
	)

Definition at line 97 of file plugplay.c.

{
    PPNP_EVENT_ENTRY EventEntry;
    UNICODE_STRING Copy;
    ULONG TotalSize;
 
    /* Allocate a big enough buffer */
    Copy.Length = 0;
    Copy.MaximumLength = DeviceId->Length + sizeof(UNICODE_NULL);
    TotalSize =
        FIELD_OFFSET(PLUGPLAY_EVENT_BLOCK, InstallDevice.DeviceId) +
        Copy.MaximumLength;
 
    EventEntry = ExAllocatePool(NonPagedPool,
                                TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
    if (!EventEntry)
        return STATUS_INSUFFICIENT_RESOURCES;
    RtlZeroMemory(EventEntry, TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
 
    /* Fill the buffer with the event GUID */
    RtlCopyMemory(&EventEntry->Event.EventGuid, EventGuid, sizeof(GUID));
    EventEntry->Event.EventCategory = DeviceInstallEvent;
    EventEntry->Event.TotalSize = TotalSize;
 
    /* Fill the symbolic link name */
    RtlCopyMemory(&EventEntry->Event.InstallDevice.DeviceId,
                  DeviceId->Buffer, DeviceId->Length);
    EventEntry->Event.InstallDevice.DeviceId[DeviceId->Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    InsertHeadList(&IopPnpEventQueueHead, &EventEntry->ListEntry);
 
    KeSetEvent(&IopPnpNotifyEvent, 0, FALSE);
 
    return STATUS_SUCCESS;
}

Referenced by PiControlInitializeDevice(), and PiInitializeDevNode().

IopQueueDevicePropertyChangeEvent()

NTSTATUS IopQueueDevicePropertyChangeEvent

(

_In_ PCUNICODE_STRING

DeviceId

)

Definition at line 136 of file plugplay.c.

{
    PPNP_EVENT_ENTRY EventEntry;
    ULONG TotalSize, EntrySize;
 
    TotalSize = FIELD_OFFSET(PLUGPLAY_EVENT_BLOCK, TargetDevice.DeviceIds) +
                DeviceId->Length + sizeof(UNICODE_NULL);
    EntrySize = FIELD_OFFSET(PNP_EVENT_ENTRY, Event) + TotalSize;
 
    EventEntry = ExAllocatePoolZero(NonPagedPool, EntrySize, TAG_IO);
    if (!EventEntry)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    EventEntry->Event.EventGuid = GUID_PNP_PROPERTY_UPDATE;
    EventEntry->Event.EventCategory = DevicePropertyChangeEvent;
    EventEntry->Event.TotalSize = TotalSize;
 
    RtlCopyMemory(EventEntry->Event.TargetDevice.DeviceIds,
                  DeviceId->Buffer, DeviceId->Length);
 
    InsertHeadList(&IopPnpEventQueueHead, &EventEntry->ListEntry);
    KeSetEvent(&IopPnpNotifyEvent, 0, FALSE);
 
    return STATUS_SUCCESS;
}

Referenced by PiPropSet().

IopQueueTargetDeviceEvent()

NTSTATUS IopQueueTargetDeviceEvent	(	const GUID *	Guid,
		PUNICODE_STRING	DeviceIds
	)

Definition at line 165 of file plugplay.c.

{
    PPNP_EVENT_ENTRY EventEntry;
    UNICODE_STRING Copy;
    ULONG TotalSize;
    NTSTATUS Status;
 
    ASSERT(DeviceIds);
 
    /* Allocate a big enough buffer */
    Copy.Length = 0;
    Copy.MaximumLength = DeviceIds->Length + sizeof(UNICODE_NULL);
    TotalSize =
        FIELD_OFFSET(PLUGPLAY_EVENT_BLOCK, TargetDevice.DeviceIds) +
        Copy.MaximumLength;
 
    EventEntry = ExAllocatePool(NonPagedPool,
                                TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
    if (!EventEntry)
        return STATUS_INSUFFICIENT_RESOURCES;
    RtlZeroMemory(EventEntry, TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
 
    /* Fill the buffer with the event GUID */
    RtlCopyMemory(&EventEntry->Event.EventGuid,
                  Guid,
                  sizeof(GUID));
    EventEntry->Event.EventCategory = TargetDeviceChangeEvent;
    EventEntry->Event.TotalSize = TotalSize;
 
    /* Fill the device id */
    Copy.Buffer = EventEntry->Event.TargetDevice.DeviceIds;
    Status = RtlAppendUnicodeStringToString(&Copy, DeviceIds);
    if (!NT_SUCCESS(Status))
    {
        ExFreePool(EventEntry);
        return Status;
    }
 
    InsertHeadList(&IopPnpEventQueueHead,
                   &EventEntry->ListEntry);
    KeSetEvent(&IopPnpNotifyEvent,
               0,
               FALSE);
 
    return STATUS_SUCCESS;
}

IopRemovePlugPlayEvent()

static NTSTATUS IopRemovePlugPlayEvent ( _In_ PPLUGPLAY_CONTROL_USER_RESPONSE_DATA  ResponseData )

static

Definition at line 419 of file plugplay.c.

{
    /* Remove a pnp event entry from the tail of the queue */
    if (!IsListEmpty(&IopPnpEventQueueHead))
    {
        ExFreePool(CONTAINING_RECORD(RemoveTailList(&IopPnpEventQueueHead), PNP_EVENT_ENTRY, ListEntry));
    }
 
    /* Signal the next pnp event in the queue */
    if (!IsListEmpty(&IopPnpEventQueueHead))
    {
        KeSetEvent(&IopPnpNotifyEvent,
                   0,
                   FALSE);
    }
 
    return STATUS_SUCCESS;
}

Referenced by NtPlugPlayControl().

IopSetDeviceInstanceData()

NTSTATUS IopSetDeviceInstanceData	(	HANDLE	InstanceKey,
		PDEVICE_NODE	DeviceNode
	)

Definition at line 606 of file pnpmgr.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING KeyName;
    HANDLE LogConfKey, ControlKey, DeviceParamsKey;
    ULONG ResCount;
    ULONG ResultLength;
    NTSTATUS Status;
 
    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,
                         // FIXME? In r53694 it was silently turned from non-volatile into this,
                         // without any extra warning. Is this still needed??
                         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_REQUIREMENTS_LIST,
                                   DeviceNode->ResourceRequirements,
                                   DeviceNode->ResourceRequirements->ListSize);
        }
 
        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));
    }
 
    /* Create the 'Control' key */
    RtlInitUnicodeString(&KeyName, L"Control");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               InstanceKey,
                               NULL);
    Status = ZwCreateKey(&ControlKey,
                         0,
                         &ObjectAttributes,
                         0,
                         NULL,
                         REG_OPTION_VOLATILE,
                         NULL);
    if (NT_SUCCESS(Status))
        ZwClose(ControlKey);
 
    /* Create the 'Device Parameters' key and set the 'FirmwareIdentified' value for all ACPI-enumerated devices */
    if (_wcsnicmp(DeviceNode->InstancePath.Buffer, L"ACPI\\", 5) == 0)
    {
        RtlInitUnicodeString(&KeyName, L"Device Parameters");
        InitializeObjectAttributes(&ObjectAttributes,
                                   &KeyName,
                                   OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                   InstanceKey,
                                   NULL);
        Status = ZwCreateKey(&DeviceParamsKey,
                             0,
                             &ObjectAttributes,
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             NULL);
        if (NT_SUCCESS(Status))
        {
            ULONG FirmwareIdentified = 1;
            RtlInitUnicodeString(&KeyName, L"FirmwareIdentified");
            Status = ZwSetValueKey(DeviceParamsKey,
                                   &KeyName,
                                   0,
                                   REG_DWORD,
                                   &FirmwareIdentified,
                                   sizeof(FirmwareIdentified));
 
            ZwClose(DeviceParamsKey);
        }
    }
 
    DPRINT("IopSetDeviceInstanceData() done\n");
 
    return Status;
}

Referenced by PiControlInitializeDevice().

NtGetPlugPlayEvent()

NTSTATUS NTAPI NtGetPlugPlayEvent	(	IN ULONG	Reserved1,
		IN ULONG	Reserved2,
		OUT PPLUGPLAY_EVENT_BLOCK	Buffer,
		IN ULONG	BufferSize
	)

Definition at line 1472 of file plugplay.c.

{
    PPNP_EVENT_ENTRY Entry;
    NTSTATUS Status;
 
    DPRINT("NtGetPlugPlayEvent() called\n");
 
    /* Function can only be called from user-mode */
    if (KeGetPreviousMode() == KernelMode)
    {
        DPRINT1("NtGetPlugPlayEvent cannot be called from kernel mode!\n");
        return STATUS_ACCESS_DENIED;
    }
 
    /* Check for Tcb privilege */
    if (!SeSinglePrivilegeCheck(SeTcbPrivilege,
                                UserMode))
    {
        DPRINT1("NtGetPlugPlayEvent: Caller does not hold the SeTcbPrivilege privilege!\n");
        return STATUS_PRIVILEGE_NOT_HELD;
    }
 
    /* Wait for a PnP event */
    DPRINT("Waiting for pnp notification event\n");
    Status = KeWaitForSingleObject(&IopPnpNotifyEvent,
                                   UserRequest,
                                   UserMode,
                                   FALSE,
                                   NULL);
    if (!NT_SUCCESS(Status) || Status == STATUS_USER_APC)
    {
        DPRINT("KeWaitForSingleObject() failed (Status %lx)\n", Status);
        ASSERT(Status == STATUS_USER_APC);
        return Status;
    }
 
    /* Get entry from the tail of the queue */
    Entry = CONTAINING_RECORD(IopPnpEventQueueHead.Blink,
                              PNP_EVENT_ENTRY,
                              ListEntry);
 
    /* Check the buffer size */
    if (BufferSize < Entry->Event.TotalSize)
    {
        DPRINT1("Buffer is too small for the pnp-event\n");
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    /* Copy event data to the user buffer */
    _SEH2_TRY
    {
        ProbeForWrite(Buffer,
                      Entry->Event.TotalSize,
                      sizeof(UCHAR));
        RtlCopyMemory(Buffer,
                      &Entry->Event,
                      Entry->Event.TotalSize);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    DPRINT("NtGetPlugPlayEvent() done\n");
 
    return STATUS_SUCCESS;
}

Referenced by PnpEventThread().

NtPlugPlayControl()

NTSTATUS NTAPI NtPlugPlayControl	(	IN PLUGPLAY_CONTROL_CLASS	PlugPlayControlClass,
		IN OUT PVOID	Buffer,
		IN ULONG	BufferLength
	)

Definition at line 1602 of file plugplay.c.

{
    DPRINT("NtPlugPlayControl(%d %p %lu) called\n",
           PlugPlayControlClass, Buffer, BufferLength);
 
    /* Function can only be called from user-mode */
    if (KeGetPreviousMode() == KernelMode)
    {
        DPRINT1("NtGetPlugPlayEvent cannot be called from kernel mode!\n");
        return STATUS_ACCESS_DENIED;
    }
 
    /* Check for Tcb privilege */
    if (!SeSinglePrivilegeCheck(SeTcbPrivilege,
                                UserMode))
    {
        DPRINT1("NtGetPlugPlayEvent: Caller does not hold the SeTcbPrivilege privilege!\n");
        return STATUS_PRIVILEGE_NOT_HELD;
    }
 
    /* Probe the buffer */
    _SEH2_TRY
    {
        ProbeForWrite(Buffer,
                      BufferLength,
                      sizeof(ULONG));
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    switch (PlugPlayControlClass)
    {
        case PlugPlayControlEnumerateDevice:
            if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_ENUMERATE_DEVICE_DATA))
                return STATUS_INVALID_PARAMETER;
            // the Flags field is not used anyway
            return PiControlSyncDeviceAction((PPLUGPLAY_CONTROL_DEVICE_CONTROL_DATA)Buffer,
                                             PlugPlayControlClass);
 
//        case PlugPlayControlRegisterNewDevice:
//        case PlugPlayControlDeregisterDevice:
 
        case PlugPlayControlInitializeDevice:
            if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_DEVICE_CONTROL_DATA))
                return STATUS_INVALID_PARAMETER;
            return PiControlInitializeDevice((PPLUGPLAY_CONTROL_DEVICE_CONTROL_DATA)Buffer);
 
        case PlugPlayControlStartDevice:
        case PlugPlayControlResetDevice:
            if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_DEVICE_CONTROL_DATA))
                return STATUS_INVALID_PARAMETER;
            return PiControlSyncDeviceAction((PPLUGPLAY_CONTROL_DEVICE_CONTROL_DATA)Buffer,
                                             PlugPlayControlClass);
 
        case PlugPlayControlUnlockDevice:
            return STATUS_NOT_IMPLEMENTED;
 
        case PlugPlayControlQueryAndRemoveDevice:
              if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_QUERY_REMOVE_DATA))
                  return STATUS_INVALID_PARAMETER;
              return PiControlQueryRemoveDevice((PPLUGPLAY_CONTROL_QUERY_REMOVE_DATA)Buffer);
 
        case PlugPlayControlUserResponse:
            if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_USER_RESPONSE_DATA))
                return STATUS_INVALID_PARAMETER;
            return IopRemovePlugPlayEvent((PPLUGPLAY_CONTROL_USER_RESPONSE_DATA)Buffer);
 
//        case PlugPlayControlGenerateLegacyDevice:
 
        case PlugPlayControlGetInterfaceDeviceList:
            if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA))
                return STATUS_INVALID_PARAMETER;
            return IopGetInterfaceDeviceList((PPLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA)Buffer);
 
        case PlugPlayControlProperty:
            if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_PROPERTY_DATA))
                return STATUS_INVALID_PARAMETER;
            return IopGetDeviceProperty((PPLUGPLAY_CONTROL_PROPERTY_DATA)Buffer);
 
        case PlugPlayControlDeviceClassAssociation:
            if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_CLASS_ASSOCIATION_DATA))
                return STATUS_INVALID_PARAMETER;
            return PiControlDeviceClassAssociation((PPLUGPLAY_CONTROL_CLASS_ASSOCIATION_DATA)Buffer);
 
        case PlugPlayControlGetRelatedDevice:
            if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_RELATED_DEVICE_DATA))
                return STATUS_INVALID_PARAMETER;
            return IopGetRelatedDevice((PPLUGPLAY_CONTROL_RELATED_DEVICE_DATA)Buffer);
 
        case PlugPlayControlGetInterfaceDeviceAlias:
            if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_INTERFACE_ALIAS_DATA))
                return STATUS_INVALID_PARAMETER;
            return PiControlGetInterfaceDeviceAlias((PPLUGPLAY_CONTROL_INTERFACE_ALIAS_DATA)Buffer);
 
        case PlugPlayControlDeviceStatus:
            if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_STATUS_DATA))
                return STATUS_INVALID_PARAMETER;
            return IopDeviceStatus((PPLUGPLAY_CONTROL_STATUS_DATA)Buffer);
 
        case PlugPlayControlGetDeviceDepth:
            if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_DEPTH_DATA))
                return STATUS_INVALID_PARAMETER;
            return IopGetDeviceDepth((PPLUGPLAY_CONTROL_DEPTH_DATA)Buffer);
 
        case PlugPlayControlQueryDeviceRelations:
            if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_DEVICE_RELATIONS_DATA))
                return STATUS_INVALID_PARAMETER;
            return IopGetDeviceRelations((PPLUGPLAY_CONTROL_DEVICE_RELATIONS_DATA)Buffer);
 
//        case PlugPlayControlTargetDeviceRelation:
//        case PlugPlayControlQueryConflictList:
//        case PlugPlayControlRetrieveDock:
//        case PlugPlayControlHaltDevice:
//        case PlugPlayControlGetBlockedDriverList:
 
        default:
            return STATUS_NOT_IMPLEMENTED;
    }
 
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by AreDriversLoaded(), ClearDeviceStatus(), DisableDeviceInstance(), EnableDeviceInstance(), GetDeviceStatus(), GetRelationsInstanceList(), GetRelationsInstanceListSize(), InstallDriver(), PNP_CreateDevInst(), PNP_GetDepth(), PNP_GetDeviceRegProp(), PNP_GetInterfaceDeviceAlias(), PNP_GetInterfaceDeviceList(), PNP_GetInterfaceDeviceListSize(), PNP_GetRelatedDeviceInstance(), PNP_QueryRemove(), PNP_RegisterDeviceClassAssociation(), PNP_RequestDeviceEject(), PNP_RequestEjectPC(), PNP_UnregisterDeviceClassAssociation(), PnpEventThread(), ReenumerateDeviceInstance(), SetDeviceStatus(), and SetupDeviceInstance().

PiControlDeviceClassAssociation()

static NTSTATUS PiControlDeviceClassAssociation ( _In_ PPLUGPLAY_CONTROL_CLASS_ASSOCIATION_DATA  ControlData )

static

Definition at line 1353 of file plugplay.c.

{
    PDEVICE_OBJECT DeviceObject = NULL;
    UNICODE_STRING SymbolicLink;
    NTSTATUS Status;
 
    DPRINT("PiControlDeviceClassAssociation()\n");
    DPRINT("DeviceInstance: %wZ\n", &ControlData->DeviceInstance);
 
    if (ControlData->Register)
    {
        if ((ControlData->DeviceInstance.Buffer == NULL) ||
            (ControlData->DeviceInstance.Length == 0))
            return STATUS_INVALID_PARAMETER;
 
        if (ControlData->InterfaceGuid == NULL)
            return STATUS_INVALID_PARAMETER;
 
        DeviceObject = IopGetDeviceObjectFromDeviceInstance(&ControlData->DeviceInstance);
        if (DeviceObject == NULL)
            return STATUS_NO_SUCH_DEVICE;
 
        Status = IoRegisterDeviceInterface(DeviceObject,
                                           ControlData->InterfaceGuid,
                                           &ControlData->Reference,
                                           &SymbolicLink);
        if (NT_SUCCESS(Status))
        {
            if (SymbolicLink.Length + sizeof(WCHAR) <= ControlData->SymbolicLinkNameLength)
            {
                RtlCopyMemory(ControlData->SymbolicLinkName, SymbolicLink.Buffer, SymbolicLink.Length);
                ControlData->SymbolicLinkName[SymbolicLink.Length / sizeof(WCHAR)] = UNICODE_NULL;
                ControlData->SymbolicLinkNameLength = SymbolicLink.Length + sizeof(WCHAR);
            }
            else
            {
                ControlData->SymbolicLinkNameLength = SymbolicLink.Length + sizeof(WCHAR);
                Status = STATUS_BUFFER_TOO_SMALL;
            }
 
            ExFreePool(SymbolicLink.Buffer);
        }
 
        ObDereferenceObject(DeviceObject);
    }
    else
    {
        UNIMPLEMENTED;
        Status = STATUS_NOT_IMPLEMENTED;
    }
 
    return Status;
}

Referenced by NtPlugPlayControl().

PiControlGetInterfaceDeviceAlias()

static NTSTATUS PiControlGetInterfaceDeviceAlias ( _In_ PPLUGPLAY_CONTROL_INTERFACE_ALIAS_DATA  ControlData )

static

Definition at line 1332 of file plugplay.c.

{
    UNICODE_STRING AliasSymbolicLinkName;
 
    DPRINT("PiControlGetInterfaceDeviceAlias()\n");
    DPRINT("SymbolicLinkName: %wZ\n", &ControlData->SymbolicLinkName);
    DPRINT("AliasInterfaceClassGuid: %p\n", ControlData->AliasInterfaceClassGuid);
    DPRINT("AliasSymbolicLinkName: %p\n", ControlData->AliasSymbolicLinkName);
    DPRINT("AliasSymbolicLinkNameLength: %lu\n", ControlData->AliasSymbolicLinkNameLength);
 
    AliasSymbolicLinkName.Length = 0;
    AliasSymbolicLinkName.MaximumLength = ControlData->AliasSymbolicLinkNameLength;
    AliasSymbolicLinkName.Buffer = ControlData->AliasSymbolicLinkName;
    return IoGetDeviceInterfaceAlias(&ControlData->SymbolicLinkName,
                                     ControlData->AliasInterfaceClassGuid,
                                     &AliasSymbolicLinkName);
}

Referenced by NtPlugPlayControl().

PiControlInitializeDevice()

static NTSTATUS PiControlInitializeDevice ( _In_ PPLUGPLAY_CONTROL_DEVICE_CONTROL_DATA  ControlData )

static

Definition at line 317 of file plugplay.c.

{
    UNICODE_STRING DeviceInstance;
    PDEVICE_OBJECT DeviceObject;
    PDEVICE_NODE DeviceNode;
    NTSTATUS Status = STATUS_SUCCESS;
    HANDLE InstanceKey;
 
    DPRINT("PiControlInitializeDevice(%p)\n", ControlData);
 
    Status = IopCaptureUnicodeString(&DeviceInstance, &ControlData->DeviceInstance);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    DPRINT("Device: %wZ\n", &DeviceInstance);
 
    /* Leave, if the device already exists */
    DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
    if (DeviceObject != NULL)
    {
        DPRINT1("Device %wZ already exists!\n", &DeviceInstance);
        ObDereferenceObject(DeviceObject);
        Status = STATUS_SUCCESS;
        goto done;
    }
 
    DPRINT("Device %wZ does not exist!\n", &DeviceInstance);
 
    /* Create a device node for the device instance */
    Status = PnpRootCreateDeviceObject(&DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IoCreateDevice() failed (Status 0x%08lx)\n", Status);
        goto done;
    }
 
    /* Allocate a new device node */
    DeviceNode = PipAllocateDeviceNode(DeviceObject);
    if (DeviceNode == NULL)
    {
        DPRINT1("Failed to allocate a device node!\n");
        IoDeleteDevice(DeviceObject);
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto done;
    }
 
    // Set the device instance of the device node
    // NOTE: a NULL-terminated string is required for PnpRootRegisterDevice
    Status = RtlDuplicateUnicodeString(
                RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
                &DeviceInstance,
                &DeviceNode->InstancePath);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("RtlDuplicateUnicodeString() failed (Status 0x%08lx)\n", Status);
        IopFreeDeviceNode(DeviceNode);
        IoDeleteDevice(DeviceObject);
        goto done;
    }
 
    DeviceObject->Flags |= DO_BUS_ENUMERATED_DEVICE;
    DeviceNode->Flags |= DNF_MADEUP | DNF_IDS_QUERIED | DNF_ENUMERATED;
    PiSetDevNodeState(DeviceNode, DeviceNodeInitialized);
 
    Status = IopCreateDeviceKeyPath(&DeviceInstance, REG_OPTION_NON_VOLATILE, &InstanceKey);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create the instance key! (Status %lx)\n", Status);
        IopFreeDeviceNode(DeviceNode);
        IoDeleteDevice(DeviceObject);
        goto done;
    }
 
    /* Write the resource information to the registry */
    IopSetDeviceInstanceData(InstanceKey, DeviceNode);
 
    // Finish the root device registration
    PnpRootRegisterDevice(DeviceObject);
 
    /* Insert as a root enumerated device node */
    PiInsertDevNode(DeviceNode, IopRootDeviceNode);
 
    /* Report the device to the user-mode pnp manager */
    IopQueueDeviceInstallEvent(&GUID_DEVICE_ENUMERATED, &DeviceNode->InstancePath);
 
    ZwClose(InstanceKey);
done:
    ExFreePool(DeviceInstance.Buffer);
 
    return Status;
}

Referenced by NtPlugPlayControl().

PiControlQueryRemoveDevice()

static NTSTATUS PiControlQueryRemoveDevice ( _In_ PPLUGPLAY_CONTROL_QUERY_REMOVE_DATA  ControlData )

static

Definition at line 1299 of file plugplay.c.

{
    PDEVICE_OBJECT DeviceObject;
    NTSTATUS Status;
    UNICODE_STRING DeviceInstance;
 
    Status = IopCaptureUnicodeString(&DeviceInstance, &ControlData->DeviceInstance);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
    if (DeviceInstance.Buffer != NULL)
    {
        ExFreePool(DeviceInstance.Buffer);
    }
    if (DeviceObject == NULL)
    {
        return STATUS_NO_SUCH_DEVICE;
    }
 
    UNIMPLEMENTED;
    Status = STATUS_NOT_IMPLEMENTED;
 
    ObDereferenceObject(DeviceObject);
 
    return Status;
}

Referenced by NtPlugPlayControl().

PiControlSyncDeviceAction()

static NTSTATUS PiControlSyncDeviceAction ( _In_ PPLUGPLAY_CONTROL_DEVICE_CONTROL_DATA  DeviceData, _In_ PLUGPLAY_CONTROL_CLASS  ControlClass  )

static

Definition at line 1244 of file plugplay.c.

{
    PDEVICE_OBJECT DeviceObject;
    NTSTATUS Status;
    UNICODE_STRING DeviceInstance;
 
    ASSERT(ControlClass == PlugPlayControlEnumerateDevice ||
           ControlClass == PlugPlayControlStartDevice ||
           ControlClass == PlugPlayControlResetDevice);
 
    Status = IopCaptureUnicodeString(&DeviceInstance, &DeviceData->DeviceInstance);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
    if (DeviceInstance.Buffer != NULL)
    {
        ExFreePool(DeviceInstance.Buffer);
    }
    if (DeviceObject == NULL)
    {
        return STATUS_NO_SUCH_DEVICE;
    }
 
    DEVICE_ACTION Action;
 
    switch (ControlClass)
    {
        case PlugPlayControlEnumerateDevice:
            Action = PiActionEnumDeviceTree;
            break;
        case PlugPlayControlStartDevice:
            Action = PiActionStartDevice;
            break;
        case PlugPlayControlResetDevice:
            Action = PiActionResetDevice;
            break;
        default:
            UNREACHABLE;
            break;
    }
 
    Status = PiPerformSyncDeviceAction(DeviceObject, Action);
 
    ObDereferenceObject(DeviceObject);
 
    return Status;
}

Referenced by NtPlugPlayControl().

PiIsDevNodeStarted()

static BOOLEAN PiIsDevNodeStarted ( _In_ PDEVICE_NODE  DeviceNode )

static

Definition at line 890 of file plugplay.c.

{
    return (DeviceNode->State == DeviceNodeStartPending ||
            DeviceNode->State == DeviceNodeStartCompletion ||
            DeviceNode->State == DeviceNodeStartPostWork ||
            DeviceNode->State == DeviceNodeStarted ||
            DeviceNode->State == DeviceNodeQueryStopped ||
            DeviceNode->State == DeviceNodeEnumeratePending ||
            DeviceNode->State == DeviceNodeEnumerateCompletion ||
            DeviceNode->State == DeviceNodeStopped ||
            DeviceNode->State == DeviceNodeRestartCompletion);
}

Referenced by IopGetDeviceNodeStatus().

Variable Documentation

IopPnpEventQueueHead

LIST_ENTRY IopPnpEventQueueHead

static

Definition at line 30 of file plugplay.c.

Referenced by IopInitPlugPlayEvents(), IopQueueDeviceChangeEvent(), IopQueueDeviceInstallEvent(), IopQueueDevicePropertyChangeEvent(), IopQueueTargetDeviceEvent(), IopRemovePlugPlayEvent(), and NtGetPlugPlayEvent().

IopPnpNotifyEvent

KEVENT IopPnpNotifyEvent

static

Definition at line 31 of file plugplay.c.

Referenced by IopInitPlugPlayEvents(), IopQueueDeviceChangeEvent(), IopQueueDeviceInstallEvent(), IopQueueDevicePropertyChangeEvent(), IopQueueTargetDeviceEvent(), IopRemovePlugPlayEvent(), and NtGetPlugPlayEvent().