#include <fxwmiirphandler.hpp>

Inheritance diagram for FxWmiIrpHandler:

[legend]

Collaboration diagram for FxWmiIrpHandler:

[legend]

Public Member Functions
	FxWmiIrpHandler (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in CfxDevice *Device, __in WDFTYPE Type=FX_TYPE_WMI_IRP_HANDLER)

	~FxWmiIrpHandler ()

_Must_inspect_result_ NTSTATUS	PostCreateDeviceInitialize (VOID)

_Must_inspect_result_ NTSTATUS	HandleWmiTraceRequest (__in PIRP Irp, __in FxTraceInfo *Info)

virtual _Must_inspect_result_ NTSTATUS	Dispatch (__in PIRP Irp)

_Must_inspect_result_ NTSTATUS	Register (VOID)

VOID	Deregister (VOID)

VOID	Cleanup (VOID)

VOID	ResetStateForPdoRestart (VOID)

_Must_inspect_result_ NTSTATUS	AddProvider (__in FxWmiProvider *Provider, __out_opt PBOOLEAN Update=NULL)

_Must_inspect_result_ NTSTATUS	AddPowerPolicyProviderAndInstance (__in PWDF_WMI_PROVIDER_CONFIG ProviderConfig, __in FxWmiInstanceInternalCallbacks Callbacks, __inout FxWmiInstanceInternal *Instance)

Public Member Functions inherited from FxPackage
	FxPackage (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in CfxDevice *Device, __in WDFTYPE Type)

virtual NTSTATUS	Dispatch (__in MdIrp Irp)=0

__inline CfxDevice *	GetDevice (VOID)

	DECLARE_INTERNAL_NEW_OPERATOR ()

Public Member Functions inherited from FxNonPagedObject
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)

virtual	~FxNonPagedObject (VOID)

	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_maxIRQL(DISPATCH_LEVEL) __drv_setsIRQL(DISPATCH_LEVEL) VOID Lock(__out __drv_deref(__drv_savesIRQL) PKIRQL PreviousIrql)

	_Releases_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID Unlock(__in __drv_restoresIRQL KIRQL PreviousIrql)

	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) VOID LockAtDispatch(VOID)

	_Requires_lock_held_ (this->m_NPLock.m_Lock) _Releases_lock_(this -> m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID UnlockFromDispatch(VOID)

Public Member Functions inherited from FxObject
PVOID	GetCOMWrapper ()

void	SetCOMWrapper (__drv_aliasesMem PVOID Wrapper)

	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

virtual	~FxObject (VOID)

PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType Type)

PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __in USHORT ExtraSize=0)

VOID	operator delete (__in PVOID Memory)

VOID	SetNoContextHeader (VOID)

PVOID __inline	GetObjectHandle (VOID)

__inline FxContextHeader *	GetContextHeader (VOID)

__inline PFX_DRIVER_GLOBALS	GetDriverGlobals (VOID)

WDFTYPE	GetType (VOID)

USHORT	GetObjectSize (VOID)

LONG	GetRefCnt (VOID)

FxTagTracker *	GetTagTracker (VOID)

CfxDevice *	GetDevice (VOID)

CfxDeviceBase *	GetDeviceBase (VOID)

VOID	SetDeviceBase (__in CfxDeviceBase *DeviceBase)

__inline VOID	CallCleanup (VOID)

ULONG __inline	AddRef (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	Release (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	AddRefOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	ReleaseOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__in FxQueryInterfaceParams *Params)

VOID	MarkTraceState (VOID)

BOOLEAN __inline	IsTraceState (VOID)

VOID __inline	TraceDroppedEvent (__in FxObjectDroppedEvent Event)

VOID	MarkPassiveDispose (__in FxObjectLockState State=ObjectLock)

VOID	MarkPassiveCallbacks (__in FxObjectLockState State=ObjectLock)

VOID	MarkForceDisposeThread (__in FxObjectLockState State=ObjectLock)

BOOLEAN	IsPassiveCallbacks (__in BOOLEAN AcquireLock=TRUE)

BOOLEAN	IsPassiveDispose (__in BOOLEAN AcquireLock=TRUE)

BOOLEAN	IsForceDisposeThread (__in BOOLEAN AcquireLock=TRUE)

VOID	MarkCommitted (VOID)

BOOLEAN	IsCommitted (VOID)

VOID	MarkDisposeOverride (__in FxObjectLockState State=ObjectLock)

VOID	MarkNoDeleteDDI (__in FxObjectLockState State=ObjectLock)

BOOLEAN	IsNoDeleteDDI (VOID)

_Must_inspect_result_ NTSTATUS	Commit (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out_opt WDFOBJECT ObjectHandle, __in_opt FxObject Parent=NULL, __in BOOLEAN AssignDriverAsDefaultParent=TRUE)

VOID	DeleteFromFailedCreate (VOID)

VOID	ClearEvtCallbacks (VOID)

BOOLEAN	EarlyDispose (VOID)

virtual VOID	DeleteObject (VOID)

virtual BOOLEAN	Dispose (VOID)

_Must_inspect_result_ NTSTATUS	AssignParentObject (__in FxObject *ParentObject)

_Must_inspect_result_ NTSTATUS	AddContext (__in FxContextHeader Header, __in PVOID Context, __in PWDF_OBJECT_ATTRIBUTES Attributes)

_Must_inspect_result_ NTSTATUS	RemoveParentAssignment (VOID)

_Must_inspect_result_ FxObject *	GetParentObjectReferenced (__in PVOID Tag)

BOOLEAN	IsDisposed (VOID)

Protected Types
enum	WmiRegisteredState { WmiUnregistered = 0 , WmiRegistered , WmiDeregistered , WmiCleanedUp }

Protected Member Functions
_Must_inspect_result_ NTSTATUS	AddProviderLocked (__in FxWmiProvider *Provider, __in KIRQL Irql, __out_opt PBOOLEAN Update=NULL)

VOID	RemoveProvider (__in FxWmiProvider *Provider)

VOID	RemoveProviderLocked (__in FxWmiProvider *Provider)

_Must_inspect_result_ FxWmiProvider *	FindProviderLocked (__in LPGUID Guid)

_Must_inspect_result_ FxWmiProvider *	FindProviderReferenced (__in LPGUID Guid, __in PVOID Tag)

Protected Member Functions inherited from FxObject
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)

FxObjectDebugExtension *	GetDebugExtension (VOID)

BOOLEAN	IsDebug (VOID)

VOID	AllocateTagTracker (__in WDFTYPE Type)

virtual VOID	SelfDestruct (VOID)

PVOID __inline	GetObjectHandleUnchecked (VOID)

VOID __inline	DestroyChildren (VOID)

VOID	DeleteEarlyDisposedObject (VOID)

Static Protected Member Functions
static VOID	CheckAssumptions (VOID)

Static Protected Member Functions inherited from FxObject
static PVOID	_GetBase (__in FxObject *Object)

Protected Attributes
LIST_ENTRY	m_ProvidersListHead

ULONG	m_NumProviders

WmiRegisteredState	m_RegisteredState

PIO_WORKITEM	m_WorkItem

LONG	m_UpdateCount

FxCREvent	m_UpdateEvent

PKEVENT	m_WorkItemEvent

BOOLEAN	m_WorkItemQueued

Protected Attributes inherited from FxObject
union {
CfxDeviceBase * m_DeviceBase

CfxDevice * m_Device

};

Static Protected Attributes
static const FxWmiMinorEntry	m_WmiDispatchTable []

Static Private Member Functions
static _Must_inspect_result_ NTSTATUS	_QueryAllData (__in FxWmiIrpHandler This, __in PIRP Irp, __in FxWmiProvider Provider, __in_opt FxWmiInstance *Instance)

static _Must_inspect_result_ NTSTATUS	_QuerySingleInstance (__in FxWmiIrpHandler This, __in PIRP Irp, __in FxWmiProvider Provider, __in FxWmiInstance *Instance)

static _Must_inspect_result_ NTSTATUS	_ChangeSingleInstance (__in FxWmiIrpHandler This, __in PIRP Irp, __in FxWmiProvider Provider, __in FxWmiInstance *Instance)

static _Must_inspect_result_ NTSTATUS	_ChangeSingleItem (__in FxWmiIrpHandler This, __in PIRP Irp, __in FxWmiProvider Provider, __in FxWmiInstance *Instance)

static _Must_inspect_result_ NTSTATUS	_EnableDisableEventsAndCollection (__in FxWmiIrpHandler This, __in PIRP Irp, __in FxWmiProvider Provider, __in FxWmiInstance *Instance)

static _Must_inspect_result_ NTSTATUS	_RegInfo (__in FxWmiIrpHandler This, __in PIRP Irp, __in_opt FxWmiProvider Provider, __in_opt FxWmiInstance *Instance)

static _Must_inspect_result_ NTSTATUS	_ExecuteMethod (__in FxWmiIrpHandler This, __in PIRP Irp, __in FxWmiProvider Provider, __in FxWmiInstance *Instance)

Private Attributes
friend	FxWmiProvider

Static Private Attributes
static MX_WORKITEM_ROUTINE	_UpdateGuids

Additional Inherited Members
Static Public Member Functions inherited from FxObject
static FxObject *	_FromDisposeEntry (__in PSINGLE_LIST_ENTRY Entry)

static FxObject *	_GetObjectFromHandle (__in WDFOBJECT Handle, __inout PWDFOBJECT_OFFSET ObjectOffset)

static PVOID __inline	_ToHandle (__in FxObject *Object)

static VOID __inline	_ReferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)

static VOID __inline	_DereferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)

static PVOID	_GetDebugBase (__in FxObject *Object)

static PFX_POOL_HEADER	_CleanupPointer (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Object)

static _Must_inspect_result_ NTSTATUS	_GetEffectiveLock (__in FxObject Object, __in_opt IFxHasCallbacks Callbacks, __in BOOLEAN AutomaticLocking, __in BOOLEAN PassiveCallbacks, __out FxCallbackLock CallbackLock, __out_opt FxObject CallbackLockObject)

static _Must_inspect_result_ NTSTATUS	_ObjectQuery (_In_ FxObject Object, _In_ CONST GUID Guid, _In_ ULONG QueryBufferLength, _Out_writes_bytes_(QueryBufferLength) PVOID QueryBuffer)

Detailed Description

Definition at line 44 of file fxwmiirphandler.hpp.

Member Enumeration Documentation

◆ WmiRegisteredState

enum FxWmiIrpHandler::WmiRegisteredState

protected

Enumerator
WmiUnregistered
WmiRegistered
WmiDeregistered
WmiCleanedUp

Definition at line 293 of file fxwmiirphandler.hpp.

                            {
        WmiUnregistered = 0,
        WmiRegistered,
        WmiDeregistered,
        WmiCleanedUp
    };

Constructor & Destructor Documentation

◆ FxWmiIrpHandler()

FxWmiIrpHandler::FxWmiIrpHandler	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in CfxDevice *	Device,
		__in WDFTYPE	Type = `FX_TYPE_WMI_IRP_HANDLER`
	)

Definition at line 83 of file fxwmiirphandler.cpp.

      :
    FxPackage(FxDriverGlobals, Device, Type),
    m_NumProviders(0), m_RegisteredState(WmiUnregistered),
    m_WorkItem(NULL), m_WorkItemEvent(NULL), m_WorkItemQueued(FALSE),
    m_UpdateCount(1) // bias m_UpdateCount to 1, Deregister routine will
                     // decrement this.
{
    InitializeListHead(&m_ProvidersListHead);
}

◆ ~FxWmiIrpHandler()

FxWmiIrpHandler::~FxWmiIrpHandler ( )

Definition at line 97 of file fxwmiirphandler.cpp.

{
    //
    // If the device could not get past AddDevice or failed the initial start
    // device, we will be unregistered.  Otherwise we should be cleaned up.
    //
    ASSERT(m_RegisteredState != WmiRegistered);
 
    ASSERT(IsListEmpty(&m_ProvidersListHead));
 
    if (m_WorkItem != NULL) {
        IoFreeWorkItem(m_WorkItem);
    }
}

Member Function Documentation

◆ _ChangeSingleInstance()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::_ChangeSingleInstance	(	__in FxWmiIrpHandler *	This,
		__in PIRP	Irp,
		__in FxWmiProvider *	Provider,
		__in FxWmiInstance *	Instance
	)

staticprivate

Definition at line 1297 of file fxwmiirphandler.cpp.

{
    PWNODE_SINGLE_INSTANCE pSingle;
    PIO_STACK_LOCATION stack;
    NTSTATUS status;
    ULONG size;
 
    size = 0;
 
    stack = IoGetCurrentIrpStackLocation(Irp);
    pSingle = (PWNODE_SINGLE_INSTANCE) stack->Parameters.WMI.Buffer;
 
    if (Instance->IsSetInstanceSupported() == FALSE) {
        status = STATUS_WMI_READ_ONLY;
    }
    else if (pSingle->SizeDataBlock < Provider->m_MinInstanceBufferSize) {
        size = Provider->m_MinInstanceBufferSize;
        status = STATUS_BUFFER_TOO_SMALL;
    }
    else {
        status = STATUS_SUCCESS;
    }
 
    if (NT_SUCCESS(status)) {
        size = pSingle->SizeDataBlock;
 
        status = Instance->SetInstance(
            pSingle->SizeDataBlock,
            size == 0 ?
                NULL : WDF_PTR_ADD_OFFSET(pSingle, pSingle->DataBlockOffset)
            );
 
        ASSERT(status != STATUS_PENDING);
        if (status == STATUS_PENDING) {
            status = STATUS_UNSUCCESSFUL;
            size = 0;
        }
    }
 
    status = This->CompleteWmiRequest(Irp, status, size);
 
    return status;
}

◆ _ChangeSingleItem()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::_ChangeSingleItem	(	__in FxWmiIrpHandler *	This,
		__in PIRP	Irp,
		__in FxWmiProvider *	Provider,
		__in FxWmiInstance *	Instance
	)

staticprivate

Definition at line 1348 of file fxwmiirphandler.cpp.

{
    PWNODE_SINGLE_ITEM pSingle;
    NTSTATUS status;
    ULONG size;
 
    UNREFERENCED_PARAMETER(Provider);
 
    size = 0;
 
    pSingle = (PWNODE_SINGLE_ITEM) IoGetCurrentIrpStackLocation(Irp)->
        Parameters.WMI.Buffer;
 
    if (Instance->IsSetItemSupported() == FALSE) {
        status = STATUS_WMI_READ_ONLY;
    }
    else {
        status = STATUS_SUCCESS;
    }
 
    if (NT_SUCCESS(status)) {
        status = Instance->SetItem(
            pSingle->ItemId,
            pSingle->SizeDataItem,
            pSingle->SizeDataItem == 0 ?
                NULL : WDF_PTR_ADD_OFFSET(pSingle, pSingle->DataBlockOffset)
            );
 
        ASSERT(status != STATUS_PENDING);
        if (status == STATUS_PENDING) {
            status = STATUS_UNSUCCESSFUL;
            size = 0;
        }
    }
 
    status = This->CompleteWmiRequest(Irp, status, size);
 
    return status;
}

◆ _EnableDisableEventsAndCollection()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::_EnableDisableEventsAndCollection	(	__in FxWmiIrpHandler *	This,
		__in PIRP	Irp,
		__in FxWmiProvider *	Provider,
		__in FxWmiInstance *	Instance
	)

staticprivate

Definition at line 1395 of file fxwmiirphandler.cpp.

{
    NTSTATUS status;
    BOOLEAN enable;
    WDF_WMI_PROVIDER_CONTROL control;
    PIO_STACK_LOCATION stack;
 
    UNREFERENCED_PARAMETER(This);
    UNREFERENCED_PARAMETER(Instance);
 
    Irp->IoStatus.Information = 0;
 
    stack = IoGetCurrentIrpStackLocation(Irp);
 
    if (stack->Parameters.WMI.BufferSize < sizeof(WNODE_HEADER)) {
        status = STATUS_INVALID_PARAMETER;
        goto Done;
    }
 
    switch (stack->MinorFunction) {
    case IRP_MN_ENABLE_EVENTS:
        enable = TRUE;
        control =  WdfWmiEventControl;
        break;
 
    case IRP_MN_DISABLE_EVENTS:
        enable = FALSE;
        control = WdfWmiEventControl;
        break;
 
    case IRP_MN_ENABLE_COLLECTION:
        enable = TRUE;
        control = WdfWmiInstanceControl;
        break;
 
    case IRP_MN_DISABLE_COLLECTION:
        enable = FALSE;
        control = WdfWmiInstanceControl;
        break;
 
    default:
        status = Irp->IoStatus.Status;
        goto Done;
    }
 
    if (control == WdfWmiEventControl) {
        Provider->m_EventControlEnabled = enable;
 
        //
        // Capture the tracing information before making the callback
        //
        if (Provider->m_Flags & WdfWmiProviderTracing) {
            Provider->SetTracingHandle(
                ((PWNODE_HEADER) stack->Parameters.WMI.Buffer)->HistoricalContext
                );
        }
    }
    else {
        Provider->m_DataBlockControlEnabled = enable;
    }
 
    if (Provider->IsFunctionControlSupported()) {
        status = Provider->FunctionControl(control, enable);
    }
    else {
        status = STATUS_SUCCESS;
    }
 
    ASSERT(status != STATUS_PENDING);
    if (status == STATUS_PENDING) {
        status = STATUS_UNSUCCESSFUL;
    }
 
    //
    // Undo the previous capture on error
    //
    if (!NT_SUCCESS(status)) {
        if (control == WdfWmiEventControl) {
            Provider->m_EventControlEnabled = FALSE;
 
            if (Provider->m_Flags & WdfWmiProviderTracing) {
                Provider->SetTracingHandle(NULL);
            }
        }
        else {
            Provider->m_DataBlockControlEnabled = FALSE;
        }
 
    }
 
Done:
    Irp->IoStatus.Status = status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return status;
}

◆ _ExecuteMethod()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::_ExecuteMethod	(	__in FxWmiIrpHandler *	This,
		__in PIRP	Irp,
		__in FxWmiProvider *	Provider,
		__in FxWmiInstance *	Instance
	)

staticprivate

Definition at line 1499 of file fxwmiirphandler.cpp.

{
    PWNODE_METHOD_ITEM pMethod;
    PIO_STACK_LOCATION stack;
    NTSTATUS status;
    ULONG size, inBufferSize, outBufferSize;
 
    UNREFERENCED_PARAMETER(This);
    UNREFERENCED_PARAMETER(Provider);
 
    size = 0;
 
    stack = IoGetCurrentIrpStackLocation(Irp);
    pMethod = (PWNODE_METHOD_ITEM) stack->Parameters.WMI.Buffer;
    inBufferSize = pMethod->SizeDataBlock;
    outBufferSize = stack->Parameters.WMI.BufferSize - pMethod->DataBlockOffset;
 
 
 
 
 
 
 
 
 
 
 
    if (Instance->IsExecuteMethodSupported() == FALSE) {
        //
        // WmiLib returns this value when there is no execute method function
        // pointer specified to it.
        //
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
    else {
        status = STATUS_SUCCESS;
    }
 
    if (NT_SUCCESS(status)) {
        status = Instance->ExecuteMethod(
            pMethod->MethodId,
            inBufferSize,
            outBufferSize,
            (inBufferSize == 0 && outBufferSize == 0) ?
                NULL : WDF_PTR_ADD_OFFSET(pMethod, pMethod->DataBlockOffset),
            &size
            );
 
        ASSERT(status != STATUS_PENDING);
        if (status == STATUS_PENDING) {
            status = STATUS_UNSUCCESSFUL;
            size = 0;
        }
    }
 
    status = This->CompleteWmiRequest(Irp, status, size);
 
    return status;
}

◆ _QueryAllData()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::_QueryAllData	(	__in FxWmiIrpHandler *	This,
		__in PIRP	Irp,
		__in FxWmiProvider *	Provider,
		__in_opt FxWmiInstance *	Instance
	)

staticprivate

Definition at line 813 of file fxwmiirphandler.cpp.

{
    POFFSETINSTANCEDATAANDLENGTH pOffsets;
    PWNODE_ALL_DATA pNodeData;
    PIO_STACK_LOCATION stack;
    PUCHAR pData;
    NTSTATUS status, addStatus;
    ULONG instanceCount, dataBlockOffset, lengthArraySize, i, sizeRemaining,
          lastAdjustment, bufferUsed, tempOffset;
    KIRQL irql;
    BOOLEAN tooSmall;
 
    UNREFERENCED_PARAMETER(Instance);
 
    status = STATUS_SUCCESS;
 
    stack = IoGetCurrentIrpStackLocation(Irp);
    pNodeData = (PWNODE_ALL_DATA) stack->Parameters.WMI.Buffer;
 
    lastAdjustment = 0;
    pData = NULL;
    dataBlockOffset = 0;
 
    //
    // This either the amount of buffer used on successful queries or the
    // amount of buffer required if the buffer is not big enough.
    //
    bufferUsed = 0;
 
    tooSmall = FALSE;
 
    if (stack->Parameters.WMI.BufferSize < sizeof(WNODE_ALL_DATA)) {
        status = STATUS_UNSUCCESSFUL;
        goto Done;
    }
 
 
 
 
 
 
 
    //
    // All of the provider's access is guarded by the irp handler's lock
    //
    This->Lock(&irql);
    instanceCount = Provider->m_NumInstances;
    This->Unlock(irql);
 
 
 
 
 
 
 
 
 
 
 
    if (instanceCount == 0) {
        status = STATUS_WMI_INSTANCE_NOT_FOUND;
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
            "Failing QueryAllData since no instances found for "
            "WDFWMIPROVIDER %p, %!STATUS!",
            Provider->GetHandle(), status);
        bufferUsed = 0;
        goto Done;
    }
 
    DoTraceLevelMessage(
        This->GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
        "WDFWMIPROVIDER %p QueryAllData, num instances %d",
        Provider->GetHandle(), instanceCount);
 
    pNodeData->InstanceCount = instanceCount;
 
 
 
 
 
 
    pNodeData->WnodeHeader.Flags &= ~WNODE_FLAG_FIXED_INSTANCE_SIZE;
 
    //
    // Since value of instanceCount is not limited, do overflow-safe addition
    // and multiplication
    //
    // lengthArraySize = instanceCount * sizeof(OFFSETINSTANCEDATAANDLENGTH);
    status = RtlULongMult(instanceCount,
                          sizeof(OFFSETINSTANCEDATAANDLENGTH),
                          &lengthArraySize);
 
    if (NT_SUCCESS(status)) {
        // dataBlockOffset =
        // FIELD_OFFSET(WNODE_ALL_DATA, OffsetInstanceDataAndLength) + lengthArraySize;
        status = RtlULongAdd(
            FIELD_OFFSET(WNODE_ALL_DATA, OffsetInstanceDataAndLength),
            lengthArraySize,
            &tempOffset);
 
        if (NT_SUCCESS(status)) {
            dataBlockOffset = (ULONG) WDF_ALIGN_SIZE_UP(
                tempOffset, MEMORY_ALLOCATION_ALIGNMENT);
 
            if (dataBlockOffset < tempOffset) {
                status = STATUS_INTEGER_OVERFLOW;
            }
        }
    }
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "Failing QueryAllData since integer overflow occured using"
            " provider instance count %d for WDFWMIPROVIDER %p, %!STATUS!",
            instanceCount, Provider->GetHandle(), status);
        bufferUsed = 0;
        goto Done;
    }
 
    pNodeData->DataBlockOffset = dataBlockOffset;
 
    if (dataBlockOffset <= stack->Parameters.WMI.BufferSize) {
        pOffsets = &pNodeData->OffsetInstanceDataAndLength[0];
        sizeRemaining = stack->Parameters.WMI.BufferSize - dataBlockOffset;
        pData = (PUCHAR) WDF_PTR_ADD_OFFSET(pNodeData, dataBlockOffset);
    }
    else {
        //
        // There is not enough room in the WNODE to complete the query, but
        // we still want to query all the instances to see how big a buffer the
        // caller should resend.
        //
        pOffsets = NULL;
        pData = NULL;
        sizeRemaining = 0;
 
        //
        // We are in the too small case
        //
        tooSmall = TRUE;
        status = STATUS_BUFFER_TOO_SMALL;
    }
 
    if (instanceCount > 0 && Provider->GetMinInstanceBufferSize() != 0) {
        ULONG size, minSizeAdjusted;
 
        size = 0;
 
        minSizeAdjusted = (ULONG) WDF_ALIGN_SIZE_UP(
            Provider->GetMinInstanceBufferSize(),
            MEMORY_ALLOCATION_ALIGNMENT
            );
 
        //
        // Quick size check to make sure there is enough buffer for all of the
        // instances.  We round up all but the last instance's minimum size so
        // that we can make sure we have enough room for an aligned bufer for
        // each instance.
        //
        // All but the last instance are using the adjusted size.  In the end,
        // we will have:
        //
        // size = minSizeAdjusted * (instanceCount-1) +
        //        Provider->GetMinInstanceBufferSize();
        //
        // NOTE:  we do not care about instances which do not support query
        //        data.  We don't care b/c by computing the total size of all
        //        instances we compute the maximum sized buffer needed, and if
        //        a few instances  do no support query data, then the buffer
        //        will just be too large, never too small.
        //
        status = RtlULongMult(minSizeAdjusted, instanceCount - 1, &size);
        if (!NT_SUCCESS(status)) {
            goto Done;
        }
 
        status = RtlULongAdd(size, Provider->GetMinInstanceBufferSize(), &size);
        if (!NT_SUCCESS(status)) {
            goto Done;
        }
 
        //
        // Since the client indicated that that each block as a minimum instance
        // size (which in reality is the fixed size, variable sized instnaces
        // should report a minimum instance size of zero), we can compute the
        // required buffer size w/out querying each instance for the required
        // size.
        //
        if (sizeRemaining < size) {
            //
            // bufferUsed in the buffer too small case indicates how many bytes
            // we want the caller to allocate.
            //
            bufferUsed = size;
            status = STATUS_BUFFER_TOO_SMALL;
            goto Done;
        }
    }
 
    for (i = 0; i < instanceCount; i++) {
        FxWmiInstance* pInstance;
 
        //
        // In the case where we have a minimum instance size, we should have
        // verified correctly above to have enough buffer.
        //
        ASSERT(sizeRemaining >= Provider->GetMinInstanceBufferSize());
 
        pInstance = Provider->GetInstanceReferenced(i, Irp);
 
        if (pInstance == NULL) {
            break;
        }
 
        if (pInstance->IsQueryInstanceSupported()) {
            ULONG tmpSize;
 
            tmpSize = 0;
 
            status = pInstance->QueryInstance(sizeRemaining, pData, &tmpSize);
 
            if (NT_SUCCESS(status) || status == STATUS_BUFFER_TOO_SMALL) {
                ULONG adjustedSize;
 
                //
                // We calculate the size in both cases.  In the NT_SUCCESS case,
                // it is the amount of buffer used. In the too small case, it is
                // the amount of buffer required for a subsequent query.
                //
                adjustedSize = (ULONG) WDF_ALIGN_SIZE_UP(
                    tmpSize, MEMORY_ALLOCATION_ALIGNMENT
                    );
 
                if (adjustedSize < tmpSize) {
                    //
                    // Overflow, adjustedSize will be >= tmpSize in the normal
                    // case.
                    //
                    status = STATUS_INTEGER_OVERFLOW;
                    DoTraceLevelMessage(
                        This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                        "WDFWMIINSTNACE %p queried, returned a buffer size of %d,"
                        "but it could not be rounded up, %!STATUS!",
                        pInstance->GetHandle(), tmpSize, status);
                    goto QueryError;
                }
 
                //
                // Keep track of how much we adjusted up the size on the last
                // instance so that when compute the total buffer used, we
                // do not include the final size adjustment.
                //
                lastAdjustment = adjustedSize - tmpSize;
 
                //
                // We only write the offset and data if we have not yet
                // encountered an instance where the buffer size was too small.
                //
                if (NT_SUCCESS(status) && tooSmall == FALSE) {
                    //
                    // dataBlockOffset is where we are currently at in the buffer
                    //
                    pOffsets[i].LengthInstanceData = tmpSize;
                    pOffsets[i].OffsetInstanceData = dataBlockOffset;
 
                    pData += adjustedSize;
                }
                else {
                    tooSmall = TRUE;
                }
 
                //
                // Compute how much buffer we have left and our offset into it.
                //
                if (adjustedSize <= sizeRemaining) {
                    sizeRemaining -= adjustedSize;
 
                    //
                    // dataBlockOffset += adjustedSize;
                    //
                    addStatus = RtlULongAdd(dataBlockOffset,
                                            adjustedSize,
                                            &dataBlockOffset);
                }
                else {
                    //
                    // dataBlockOffset += sizeRemaining;
                    //
                    addStatus = RtlULongAdd(dataBlockOffset,
                                            sizeRemaining,
                                            &dataBlockOffset);
                    sizeRemaining = 0;
                }
 
                if (!NT_SUCCESS(addStatus)) {
                    status = addStatus;
                    DoTraceLevelMessage(
                        This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                        "WDFWMIPROVIDER %p, arithmetic overflow in computing "
                        "block offset, %!STATUS!", Provider->GetHandle(),
                        status);
                    goto QueryError;
                }
 
                //
                // Compute how much buffer space we have used or require the
                // caller to provide.  This is just the count of bytes for the
                // data queried, it does not yet include the array size required
                // to report offset & lengths.
                //
                // bufferUsed += adjustedSize;
                //
                addStatus = RtlULongAdd(bufferUsed, adjustedSize, &bufferUsed);
 
                if (!NT_SUCCESS(addStatus)) {
                    status = addStatus;
                    DoTraceLevelMessage(
                        This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                        "WDFWMIPROVIDER %p, arithmetic overflow in computing "
                        "buffer consumed(%d+%d), %!STATUS!",
                        Provider->GetHandle(), bufferUsed, adjustedSize, status);
                    goto QueryError;
                }
            }
        }
        else if (pOffsets != NULL) {
            //
            // Indicate no buffer and the current offset.  If there any
            // other instances after this one, they will share the same
            // offset.
            //
            pOffsets[i].LengthInstanceData = 0;
            pOffsets[i].OffsetInstanceData = dataBlockOffset;
        }
 
QueryError:
        pInstance->RELEASE(Irp);
 
        //
        // We continue on STATUS_BUFFER_TOO_SMALL so that we can ask each
        // instance the amount of buffer it needs.
        //
        if (!NT_SUCCESS(status) && status != STATUS_BUFFER_TOO_SMALL) {
            break;
        }
    }
 
    //
    // We can have STATUS_BUFFER_TOO_SMALL if the last instance could not fit
    // its data into the buffer or have success if the last instance could write
    // its data, but a previous instance could not.
    //
    if (status == STATUS_BUFFER_TOO_SMALL || (NT_SUCCESS(status) && tooSmall)) {
        //
        // Since we align up the size of each block to MEMORY_ALLOCATION_ALIGNMENT,
        // the total buffer size is possibly adjusted up too high.  Subtract the
        // last adjustment made for alignment when computing the instance size
        // so that our total size is not rounded up.
        //
        // CompleteWmiQueryAllDataRequest will take care of adding enough space
        // to the requested size to account for the array of instance offsets
        // and lengths.
        //
        bufferUsed -=lastAdjustment;
 
        status = STATUS_BUFFER_TOO_SMALL;
 
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
            "WDFWMIPROVIDER %p QueryAllData returning %!STATUS!, requesting "
            "buffer size of 0x%x", Provider->GetHandle(), status, bufferUsed);
    }
    else if (NT_SUCCESS(status)) {
        //
        // Compute the total amount of buffer used.  dataBlockOffset is the
        // offset of the next instance, which is one past the end, so just
        // compute the distance from the start.
        //
        // Since align up the size of each block to MEMORY_ALLOCATION_ALIGNMENT,
        // the total buffer size is possibly adjusted up too high.  Subtract the
        // last adjustment made for alignment when computing the instance size
        // so that our total size is not rounded up.
        //
        ASSERT(dataBlockOffset >= pNodeData->DataBlockOffset);
        ASSERT(dataBlockOffset - pNodeData->DataBlockOffset >= lastAdjustment);
        bufferUsed = dataBlockOffset - pNodeData->DataBlockOffset - lastAdjustment;
    }
    else {
        DoTraceLevelMessage(
            This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "WDFWMIPROVIDER %p QueryAllData returning %!STATUS!",
            Provider->GetHandle(), status);
 
        bufferUsed = 0;
    }
 
    DoTraceLevelMessage(
        This->GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
        "WDFWMIPROVIDER %p QueryAllData returning %!STATUS!, buffer used 0x%x",
        Provider->GetHandle(), status, bufferUsed);
 
Done:
    status = This->CompleteWmiRequest(Irp, status, bufferUsed);
 
    return status;
}

◆ _QuerySingleInstance()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::_QuerySingleInstance	(	__in FxWmiIrpHandler *	This,
		__in PIRP	Irp,
		__in FxWmiProvider *	Provider,
		__in FxWmiInstance *	Instance
	)

staticprivate

Definition at line 1251 of file fxwmiirphandler.cpp.

{
    PWNODE_SINGLE_INSTANCE pSingle;
    PIO_STACK_LOCATION stack;
    NTSTATUS status;
    ULONG size, bufferSize;
 
    size = 0;
 
    stack = IoGetCurrentIrpStackLocation(Irp);
    pSingle = (PWNODE_SINGLE_INSTANCE) stack->Parameters.WMI.Buffer;
    bufferSize = stack->Parameters.WMI.BufferSize - pSingle->DataBlockOffset;
 
    if (Instance->IsQueryInstanceSupported() == FALSE) {
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
    else if (bufferSize < Provider->GetMinInstanceBufferSize()) {
        size = Provider->GetMinInstanceBufferSize();
        status = STATUS_BUFFER_TOO_SMALL;
    }
    else {
        status = STATUS_SUCCESS;
    }
 
    if (NT_SUCCESS(status)) {
        status = Instance->QueryInstance(
            bufferSize,
            WDF_PTR_ADD_OFFSET(pSingle, pSingle->DataBlockOffset),
            &size
            );
 
        pSingle->SizeDataBlock = size;
    }
 
    status = This->CompleteWmiRequest(Irp, status, size);
 
    return status;
}

◆ _RegInfo()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::_RegInfo	(	__in FxWmiIrpHandler *	This,
		__in PIRP	Irp,
		__in_opt FxWmiProvider *	Provider,
		__in_opt FxWmiInstance *	Instance
	)

staticprivate

Definition at line 1566 of file fxwmiirphandler.cpp.

{
    PIO_STACK_LOCATION stack;
    PUNICODE_STRING pRegPath;
    PWMIREGINFO pWmiRegInfo;
    PUCHAR pBuffer;
    PUNICODE_STRING pMofString;
    FxDevice* pDevice;
    NTSTATUS status;
    ULONG registryPathOffset, mofResourceOffset, bufferNeeded, information,
          bufferSize;
    KIRQL irql;
 
    UNREFERENCED_PARAMETER(Provider);
    UNREFERENCED_PARAMETER(Instance);
 
    information = 0;
 
    stack = IoGetCurrentIrpStackLocation(Irp);
    pBuffer = (PUCHAR) stack->Parameters.WMI.Buffer;
    bufferSize = stack->Parameters.WMI.BufferSize;
 
    pDevice = This->m_Device;
 
    This->Lock(&irql);
 
    mofResourceOffset = sizeof(WMIREGINFO) +
                        This->m_NumProviders * sizeof(WMIREGGUIDW);
 
    pMofString = NULL;
 
    if (pDevice->m_MofResourceName.Buffer != NULL) {
        pMofString = &pDevice->m_MofResourceName;
    }
    else {
        //
        // Start with the parent and iterate up until we hit a device without
        // a parent.
        //
        pDevice = pDevice->m_ParentDevice;
 
        while (pDevice != NULL) {
            if (pDevice->m_MofResourceName.Buffer != NULL) {
                pMofString = &pDevice->m_MofResourceName;
                break;
            }
 
            //
            // Advance to the next ancestor
            //
            pDevice = pDevice->m_ParentDevice;
        }
 
        //
        // Restore pDevice back to this device
        //
        pDevice = This->m_Device;
    }
 
    pRegPath = pDevice->GetDriver()->GetRegistryPathUnicodeString();
 
    //
    // if there is a mof string, add its length.  We always need to at least
    // add the USHORT to indicate a string of size 0.
    //
    registryPathOffset = mofResourceOffset + sizeof(USHORT);
    if (pMofString != NULL) {
        registryPathOffset += pMofString->Length;
    }
 
    //
    // eventually bufferNeeded = registryPathOffset + pRegPath->Length +
    //                           sizeof(USHORT)
    //
    status = RtlULongAdd(registryPathOffset, pRegPath->Length, &bufferNeeded);
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    status = RtlULongAdd(bufferNeeded, sizeof(USHORT), &bufferNeeded);
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    if (bufferNeeded <= bufferSize) {
        PLIST_ENTRY ple;
        ULONG i;
        BOOLEAN addref;
 
        information = bufferNeeded;
 
        pWmiRegInfo = (PWMIREGINFO) pBuffer;
        pWmiRegInfo->BufferSize = bufferNeeded;
        pWmiRegInfo->NextWmiRegInfo = 0;
        pWmiRegInfo->MofResourceName = mofResourceOffset;
        pWmiRegInfo->RegistryPath = registryPathOffset;
        pWmiRegInfo->GuidCount = This->m_NumProviders;
 
        addref = IoGetCurrentIrpStackLocation(Irp)->MinorFunction == IRP_MN_REGINFO_EX
            ? TRUE : FALSE;
 
        for (ple = This->m_ProvidersListHead.Flink, i = 0;
             i < This->m_NumProviders;
             ple = ple->Flink, i++) {
 
            PWMIREGGUIDW pWmiRegGuid;
            PDEVICE_OBJECT pdo;
            FxWmiProvider* pProvider;
 
            pProvider = CONTAINING_RECORD(ple, FxWmiProvider, m_ListEntry);
 
            pWmiRegGuid = &pWmiRegInfo->WmiRegGuid[i];
 
            RtlCopyMemory(&pWmiRegGuid->Guid,
                          &pProvider->m_Guid,
                          sizeof(GUID));
 
            pWmiRegGuid->InstanceCount = pProvider->m_NumInstances;
 
            pWmiRegGuid->Flags = pProvider->GetRegistrationFlagsLocked();
 
            pdo = pDevice->GetPhysicalDevice();
            pWmiRegGuid->Pdo = (ULONG_PTR) pdo;
 
            if (addref) {
                ObReferenceObject(pdo);
            }
        }
    }
    else {
        *((PULONG) pBuffer) = bufferNeeded;
        information = sizeof(ULONG);
    }
 
    This->Unlock(irql);
 
    //
    // Must copy the strings outside of any lock since they are in paged pool
    //
    if (bufferNeeded <= bufferSize) {
        PUSHORT pLength;
 
        pLength = WDF_PTR_ADD_OFFSET_TYPE(pBuffer, mofResourceOffset, PUSHORT);
 
        if (pMofString != NULL) {
            *pLength = pMofString->Length;
 
            RtlCopyMemory(pLength + 1,
                          pMofString->Buffer,
                          pMofString->Length);
        }
        else {
            *pLength = 0;
        }
 
        pLength = WDF_PTR_ADD_OFFSET_TYPE(pBuffer, registryPathOffset, PUSHORT);
 
        *pLength = pRegPath->Length;
        RtlCopyMemory(pLength + 1,
                      pRegPath->Buffer,
                      pRegPath->Length);
    }
 
    status = STATUS_SUCCESS;
 
Done:
    if (!NT_SUCCESS(status)) {
        This->Unlock(irql);
    }
 
    Irp->IoStatus.Status = status;
    Irp->IoStatus.Information = information;
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return status;
}

◆ AddPowerPolicyProviderAndInstance()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::AddPowerPolicyProviderAndInstance	(	__in PWDF_WMI_PROVIDER_CONFIG	ProviderConfig,
		__in FxWmiInstanceInternalCallbacks *	Callbacks,
		__inout FxWmiInstanceInternal **	Instance
	)

Definition at line 422 of file fxwmiirphandler.cpp.

{
    FxWmiProvider* pProvider;
    FxWmiInstanceInternal* pInstance;
    NTSTATUS status;
    KIRQL irql;
    BOOLEAN providerAllocated, providerAdded, update;
 
    providerAllocated = FALSE;
    providerAdded = FALSE;
    update = FALSE;
 
    pInstance = NULL;
 
    status = STATUS_SUCCESS;
 
    Lock(&irql);
 
    pProvider = FindProviderLocked(&ProviderConfig->Guid);
 
    if (pProvider == NULL) {
        pProvider = new (GetDriverGlobals(), WDF_NO_OBJECT_ATTRIBUTES)
            FxWmiProvider(GetDriverGlobals(), ProviderConfig, GetDevice());
 
        if (pProvider == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto Done;
        }
 
        providerAllocated = TRUE;
 
        status = AddProviderLocked(pProvider, irql);
        if (!NT_SUCCESS(status)) {
            goto Done;
        }
 
        providerAdded = TRUE;
 
        status = pProvider->AssignParentObject(GetDevice());
        if (!NT_SUCCESS(status)) {
            goto Done;
        }
    }
    else if (pProvider->m_NumInstances > 0 &&
             (FxIsEqualGuid(pProvider->GetGUID(), &GUID_POWER_DEVICE_ENABLE) ||
              FxIsEqualGuid(pProvider->GetGUID(), &GUID_POWER_DEVICE_WAKE_ENABLE))) {
 
        DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIO,
                            "WMI Guid already registered by client driver");
        status = STATUS_WMI_GUID_DISCONNECTED;
    }
 
    if (NT_SUCCESS(status)) {
        pInstance = new (GetDriverGlobals(), WDF_NO_OBJECT_ATTRIBUTES)
            FxWmiInstanceInternal(GetDriverGlobals(), InstanceCallbacks, pProvider);
 
        if (pInstance != NULL) {
            status = pInstance->AssignParentObject(pProvider);
        }
        else {
            status = STATUS_INSUFFICIENT_RESOURCES;
        }
 
        if (NT_SUCCESS(status) &&
            InterlockedCompareExchangePointer((PVOID*) Instance,
                                              pInstance,
                                              NULL) != NULL) {
            //
            // Some other thread got here first and created an instance, just
            // bail out.  the caller will handle this specific return value
            // gracefully.
            //
            status = STATUS_OBJECT_NAME_COLLISION;
        }
        else {
            //
            // We are the first one to set the value, good for us.
            //
            DO_NOTHING();
        }
    }
 
    //
    // Add the instance only if we are successful to this point
    //
    if (NT_SUCCESS(status)) {
        //
        // Passing FALSE indicates that this instance cannot be in the list
        // when added.
        //
        status = pProvider->AddInstanceLocked(
            pInstance,
            FALSE,
            &update,
            FxWmiProvider::AddInstanceToHead
            );
    }
 
Done:
    if (NT_SUCCESS(status)) {
        if (update) {
            update = DeferUpdateLocked(irql);
        }
    }
    else if (providerAdded) {
        RemoveProviderLocked(pProvider);
    }
 
    Unlock(irql);
 
    if (NT_SUCCESS(status)) {
        if (update) {
            UpdateGuids();
        }
    }
    else {
        if (pInstance != NULL) {
            pInstance->DeleteObject();
        }
 
        if (providerAllocated) {
            pProvider->DeleteObject();
        }
    }
 
    return status;
}

◆ AddProvider()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::AddProvider	(	__in FxWmiProvider *	Provider,
		__out_opt PBOOLEAN	Update = `NULL`
	)

Definition at line 398 of file fxwmiirphandler.cpp.

{
    NTSTATUS status;
    KIRQL irql;
 
    Lock(&irql);
 
    if (IsListEmpty(&Provider->m_ListEntry) == FALSE ||
        FindProviderLocked(Provider->GetGUID()) != NULL) {
        status = STATUS_OBJECT_NAME_EXISTS;
    }
    else {
        status = AddProviderLocked(Provider, irql, Update);
    }
    Unlock(irql);
 
    return status;
}

Referenced by FxWmiProvider::_Create().

◆ AddProviderLocked()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::AddProviderLocked	(	__in FxWmiProvider *	Provider,
		__in KIRQL	Irql,
		__out_opt PBOOLEAN	Update = `NULL`
	)

protected

Definition at line 260 of file fxwmiirphandler.cpp.

{
    BOOLEAN update;
 
    update = FALSE;
 
    switch (m_RegisteredState) {
    case WmiRegistered:
        if (Provider->m_Flags & WdfWmiProviderTracing) {
            update = TRUE;
        }
    case WmiUnregistered:
        break;
 
    case WmiDeregistered:
        return STATUS_INVALID_DEVICE_STATE;
    }
 
    //
    // Didn't find it in the list, add it
    //
    m_NumProviders++;
    InsertTailList(&m_ProvidersListHead, &Provider->m_ListEntry);
 
    if (update) {
        update = DeferUpdateLocked(OldIrql);
 
        if (Update != NULL) {
            *Update = update;
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by AddPowerPolicyProviderAndInstance(), and AddProvider().

◆ CheckAssumptions()

VOID FxWmiIrpHandler::CheckAssumptions ( VOID )

staticprotected

Definition at line 75 of file fxwmiirphandler.cpp.

{
    WDFCASSERT(sizeof(m_WmiDispatchTable)/sizeof(m_WmiDispatchTable[0]) ==
               IRP_MN_REGINFO_EX + 1);
}

◆ Cleanup()

VOID FxWmiIrpHandler::Cleanup ( VOID )

Definition at line 216 of file fxwmiirphandler.cpp.

{
    KIRQL irql;
 
    Lock(&irql);
    m_RegisteredState = WmiCleanedUp;
    Unlock(irql);
}

◆ CompleteWmiExecuteMethodRequest()

VOID FxWmiIrpHandler::CompleteWmiExecuteMethodRequest	(	__in PIRP	Irp,
		__in NTSTATUS	Status,
		__in ULONG	BufferUsed
	)

private

Definition at line 1838 of file fxwmiirphandler.cpp.

{
    PWNODE_METHOD_ITEM pNodeMethod;
    ULONG bufferNeeded, information;
 
    pNodeMethod = (PWNODE_METHOD_ITEM)
        IoGetCurrentIrpStackLocation(Irp)->Parameters.WMI.Buffer;
 
    bufferNeeded = pNodeMethod->DataBlockOffset + BufferUsed;
 
    if (NT_SUCCESS(Status)) {
        pNodeMethod->WnodeHeader.BufferSize = bufferNeeded;
        pNodeMethod->SizeDataBlock = BufferUsed;
        KeQuerySystemTime(&pNodeMethod->WnodeHeader.TimeStamp);
 
        information = bufferNeeded;
    }
    else if (Status == STATUS_BUFFER_TOO_SMALL) {
        PWNODE_TOO_SMALL pNodeTooSmall;
 
        pNodeTooSmall = (PWNODE_TOO_SMALL) pNodeMethod;
 
        pNodeTooSmall->WnodeHeader.BufferSize = sizeof(WNODE_TOO_SMALL);
        pNodeTooSmall->WnodeHeader.Flags = WNODE_FLAG_TOO_SMALL;
        pNodeTooSmall->SizeNeeded = bufferNeeded;
 
        information = sizeof(WNODE_TOO_SMALL);
        Status = STATUS_SUCCESS;
    }
    else {
        information = 0;
    }
 
    Irp->IoStatus.Information = information;
    Irp->IoStatus.Status = Status;
}

Referenced by CompleteWmiRequest().

◆ CompleteWmiQueryAllDataRequest()

VOID FxWmiIrpHandler::CompleteWmiQueryAllDataRequest	(	__in PIRP	Irp,
		__in NTSTATUS	Status,
		__in ULONG	BufferUsed
	)

private

Definition at line 1750 of file fxwmiirphandler.cpp.

{
    PWNODE_ALL_DATA pNodeAllData;
    ULONG bufferNeeded, information;
    PIO_STACK_LOCATION stack;
 
    stack = IoGetCurrentIrpStackLocation(Irp);
 
    pNodeAllData = (PWNODE_ALL_DATA) stack->Parameters.WMI.Buffer;
    bufferNeeded = pNodeAllData->DataBlockOffset + BufferUsed;
 
    if (NT_SUCCESS(Status) && bufferNeeded > stack->Parameters.WMI.BufferSize) {
        Status = STATUS_BUFFER_TOO_SMALL;
    }
 
    if (NT_SUCCESS(Status)) {
        KeQuerySystemTime(&pNodeAllData->WnodeHeader.TimeStamp);
 
        pNodeAllData->WnodeHeader.BufferSize = bufferNeeded;
        information = bufferNeeded;
    }
    else if (Status == STATUS_BUFFER_TOO_SMALL) {
        PWNODE_TOO_SMALL pNodeTooSmall;
 
        pNodeTooSmall = (PWNODE_TOO_SMALL) stack->Parameters.WMI.Buffer;
 
        pNodeTooSmall->WnodeHeader.BufferSize = sizeof(WNODE_TOO_SMALL);
        pNodeTooSmall->WnodeHeader.Flags = WNODE_FLAG_TOO_SMALL;
        pNodeTooSmall->SizeNeeded = bufferNeeded;
 
        information = sizeof(WNODE_TOO_SMALL);
        Status = STATUS_SUCCESS;
    }
    else {
        information = 0;
    }
 
    Irp->IoStatus.Information = information;
    Irp->IoStatus.Status = Status;
}

Referenced by CompleteWmiRequest().

◆ CompleteWmiQuerySingleInstanceRequest()

VOID FxWmiIrpHandler::CompleteWmiQuerySingleInstanceRequest	(	__in PIRP	Irp,
		__in NTSTATUS	Status,
		__in ULONG	BufferUsed
	)

private

Definition at line 1796 of file fxwmiirphandler.cpp.

{
    PWNODE_SINGLE_INSTANCE pNodeSingle;
    ULONG bufferNeeded, information;
 
    pNodeSingle = (PWNODE_SINGLE_INSTANCE)
        IoGetCurrentIrpStackLocation(Irp)->Parameters.WMI.Buffer;
 
    bufferNeeded = pNodeSingle->DataBlockOffset + BufferUsed;
 
    if (NT_SUCCESS(Status)) {
        pNodeSingle->WnodeHeader.BufferSize = bufferNeeded;
        KeQuerySystemTime(&pNodeSingle->WnodeHeader.TimeStamp);
 
        ASSERT(pNodeSingle->SizeDataBlock <= BufferUsed);
        information = bufferNeeded;
    }
    else if (Status == STATUS_BUFFER_TOO_SMALL) {
        PWNODE_TOO_SMALL pNodeTooSmall;
 
        pNodeTooSmall = (PWNODE_TOO_SMALL) pNodeSingle;
 
        pNodeTooSmall->WnodeHeader.BufferSize = sizeof(WNODE_TOO_SMALL);
        pNodeTooSmall->WnodeHeader.Flags = WNODE_FLAG_TOO_SMALL;
        pNodeTooSmall->SizeNeeded = bufferNeeded;
 
        information = sizeof(WNODE_TOO_SMALL);
        Status = STATUS_SUCCESS;
    }
    else {
        information = 0;
    }
 
    Irp->IoStatus.Information = information;
    Irp->IoStatus.Status = Status;
}

Referenced by CompleteWmiRequest().

◆ CompleteWmiRequest()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::CompleteWmiRequest	(	__in PIRP	Irp,
		__in NTSTATUS	Status,
		__in ULONG	BufferUsed
	)

private

Definition at line 1881 of file fxwmiirphandler.cpp.

{
    switch (IoGetCurrentIrpStackLocation(Irp)->MinorFunction) {
    case IRP_MN_QUERY_ALL_DATA:
        CompleteWmiQueryAllDataRequest(Irp, Status, BufferUsed);
        break;
 
    case IRP_MN_QUERY_SINGLE_INSTANCE:
        CompleteWmiQuerySingleInstanceRequest(Irp, Status, BufferUsed);
        break;
 
    case IRP_MN_EXECUTE_METHOD:
        CompleteWmiExecuteMethodRequest(Irp, Status, BufferUsed);
        break;
 
    case IRP_MN_CHANGE_SINGLE_INSTANCE:
    case IRP_MN_CHANGE_SINGLE_ITEM:
        //
        // Lot's of drivers return STATUS_BUFFER_TOO_SMALL for an invalid buffer
        // size.  WMI expects STATUS_WMI_SET_FAILURE in this case.  Change the
        // Status to the expected value.  No way to return any size in
        // Information, the buffer is input only.
        //
        if (Status == STATUS_BUFFER_TOO_SMALL) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
                "Converting %!STATUS! to %!STATUS!",
                Status, STATUS_WMI_SET_FAILURE);
            Status = STATUS_WMI_SET_FAILURE;
        }
        //  ||   ||  Fall through  ||   ||
        //  \/   \/                \/   \/
 
    default:
        //
        // All other requests don't return any data
        //
        Irp->IoStatus.Status = Status;
        Irp->IoStatus.Information = 0;
        break;
    }
 
    //
    // One of the complete functions may have morphed the status value
    //
    Status = Irp->IoStatus.Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

◆ DecrementUpdateCount()

VOID FxWmiIrpHandler::DecrementUpdateCount ( )

inlineprivate

Definition at line 274 of file fxwmiirphandler.hpp.

                           {
        LONG count;
 
        count = InterlockedDecrement(&m_UpdateCount);
        ASSERT(count >= 0);
        if (count == 0) {
            m_UpdateEvent.Set();
        }
    }

Referenced by FxWmiProvider::_Create(), DecrementUpdateCountAndWait(), and UpdateGuids().

◆ DecrementUpdateCountAndWait()

VOID FxWmiIrpHandler::DecrementUpdateCountAndWait ( )

inlineprivate

Definition at line 285 of file fxwmiirphandler.hpp.

                                  {
 
        DecrementUpdateCount();
 
        m_UpdateEvent.EnterCRAndWaitAndLeave();
    }

Referenced by Deregister().

◆ DeferUpdateLocked()

BOOLEAN FxWmiIrpHandler::DeferUpdateLocked ( __in KIRQL OldIrql )

private

Definition at line 300 of file fxwmiirphandler.cpp.

{
    BOOLEAN checkQueue;
 
    checkQueue = FALSE;
 
    //
    // Check to see if the caller is going to return to something > PASSIVE_LEVEL.
    // If so, then always defer to the workitem.
    //
    if (OldIrql > PASSIVE_LEVEL) {
        checkQueue = TRUE;
    }
    else {
        //
        // At passive level and updates are allowed, indicate to the caller to
        // update. The caller will do registration update outside of lock but
        // update count needs to be incremented under lock, so this is done here.
        //
        IncrementUpdateCount();
        return TRUE;
    }
 
    if (checkQueue && m_WorkItemQueued == FALSE) {
        //
        // we are going to queue a workitem which will do registration update,
        // so increment the update count. Note that one work item may correspond
        // to multiple requests to update (since if the workitem is already
        // queued, it's not queued again).
        //
        IncrementUpdateCount();
 
        m_WorkItemQueued = TRUE;
        IoQueueWorkItem(m_WorkItem,
                        _UpdateGuids,
                        DelayedWorkQueue,
                        this);
    }
 
    return FALSE;
}

Referenced by FxWmiProvider::AddInstance(), AddPowerPolicyProviderAndInstance(), AddProviderLocked(), and FxWmiProvider::RemoveInstance().

◆ Deregister()

VOID FxWmiIrpHandler::Deregister ( VOID )

Definition at line 162 of file fxwmiirphandler.cpp.

{
    FxCREvent event;
    KIRQL irql;
    BOOLEAN call;
 
    call = FALSE;
 
    Lock(&irql);
    if (m_RegisteredState == WmiRegistered) {
        m_RegisteredState = WmiDeregistered;
 
        if (m_WorkItemQueued) {
 
 
 
 
 
            m_WorkItemEvent = (PKEVENT)event.GetEvent();
        }
 
        call = TRUE;
    }
    Unlock(irql);
 
    if (m_WorkItemEvent != NULL) {
        event.EnterCRAndWaitAndLeave();
    }
 
    if (call) {
        NTSTATUS status;
 
        //
        // Per WMI rules, there should not be any call to update WMI
        // registration after we have deregistered because that can lead to
        // deadlock in Pnp, so before we go ahead to deregister, let's ensure
        // that. This will wait for any pending updates to happen.
        //
        DecrementUpdateCountAndWait();
 
        status = IoWMIRegistrationControl(GetDevice()->GetDeviceObject(),
                                          WMIREG_ACTION_DEREGISTER);
 
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
                "failure deregistering WMI with OS, %!STATUS!", status);
        }
    }
}

◆ Dispatch()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::Dispatch ( __in PIRP Irp )

virtual

Definition at line 632 of file fxwmiirphandler.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    FxWmiProvider* pProvider;
    FxWmiInstance* pInstance;
    PIO_STACK_LOCATION stack;
    PDEVICE_OBJECT pAttached;
    NTSTATUS status;
    PVOID pTag;
    ULONG instanceIndex;
    KIRQL irql;
    BOOLEAN handled, completeNow;
    UCHAR minor;
 
    pFxDriverGlobals = GetDriverGlobals();
 
    FX_TRACK_DRIVER(pFxDriverGlobals);
 
    stack = IoGetCurrentIrpStackLocation(Irp);
    minor = stack->MinorFunction;
    pTag = UlongToPtr(minor);
    status = Irp->IoStatus.Status;
 
    pProvider = NULL;
    pInstance = NULL;
 
    handled = FALSE;
    completeNow = FALSE;
 
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIO,
        "WDFDEVICE 0x%p !devobj 0x%p IRP_MJ_SYSTEM_CONTROL, %!sysctrl! IRP 0x%p",
        m_Device->GetHandle(), m_Device->GetDeviceObject(), minor, Irp);
 
    //
    // Verify the minor code is within range, there is hole in the table at 0xA.
    // This check works around the hole in the table.
    //
    if (minor > IRP_MN_EXECUTE_METHOD && minor != IRP_MN_REGINFO_EX) {
        goto Done;
    }
 
    //
    // If the irp is not targetted at this device, send it down the stack
    //
    if (stack->Parameters.WMI.ProviderId != (UINT_PTR) m_Device->GetDeviceObject()) {
        goto Done;
    }
 
    if (minor == IRP_MN_REGINFO || minor == IRP_MN_REGINFO_EX) {
        status = STATUS_SUCCESS;
    }
    else {
        Lock(&irql);
 
        pProvider = FindProviderLocked((LPGUID)stack->Parameters.WMI.DataPath);
 
        if (pProvider != NULL) {
            status = STATUS_SUCCESS;
        }
        else {
            //
            // check for WMI tracing (no pProvider)
            //
            status = STATUS_WMI_GUID_NOT_FOUND;
        }
 
        if (NT_SUCCESS(status) && m_WmiDispatchTable[minor].CheckInstance) {
            PWNODE_SINGLE_INSTANCE pSingle;
 
            pSingle = (PWNODE_SINGLE_INSTANCE) stack->Parameters.WMI.Buffer;
 
            instanceIndex = pSingle->InstanceIndex;
 
            //
            // Also possible bits set in Flags related to instance names
            // WNODE_FLAG_PDO_INSTANCE_NAMES
            //
            if (pSingle->WnodeHeader.Flags & WNODE_FLAG_STATIC_INSTANCE_NAMES) {
                //
                // Try to get the instance
                //
                pInstance = pProvider->GetInstanceReferencedLocked(
                    instanceIndex, pTag);
 
                if (pInstance == NULL) {
                    status = STATUS_WMI_INSTANCE_NOT_FOUND;
                }
            }
            else {
 
 
 
 
 
 
                status = STATUS_WMI_INSTANCE_NOT_FOUND;
            }
        }
 
        if (NT_SUCCESS(status)) {
            pProvider->ADDREF(pTag);
        }
        else {
            //
            // NULL out the provider so we don't deref it later.  We could not
            // use if (pProvider != NULL && NT_SUCCESS(status) in the Done: block
            // because we could have success here, but the dispatch function
            // returns error.
            //
            pProvider = NULL;
        }
 
        Unlock(irql);
 
        if (!NT_SUCCESS(status)) {
            Irp->IoStatus.Status = status;
            completeNow = TRUE;
        }
    }
 
    if (NT_SUCCESS(status) && m_WmiDispatchTable[minor].Handler != NULL) {
        status = m_WmiDispatchTable[minor].Handler(this,
                                                   Irp,
                                                   pProvider,
                                                   pInstance);
        handled = TRUE;
    }
 
Done:
    if (pInstance != NULL) {
        pInstance->RELEASE(pTag);
        pInstance = NULL;
    }
 
    if (pProvider != NULL) {
        pProvider->RELEASE(pTag);
        pProvider = NULL;
    }
 
    if (handled == FALSE) {
        pAttached = m_Device->GetAttachedDevice();
        if (completeNow || pAttached == NULL) {
            //
            // Sent to a PDO, error in the FDO handling, or controller devobj
            // style devobj, complete it here
            //
            status = Irp->IoStatus.Status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
        }
        else {
            //
            // Request sent to PNP device object that is not a PDO, send down
            // the stack
            //
            IoSkipCurrentIrpStackLocation(Irp);
            status = IoCallDriver(pAttached, Irp);
        }
    }
 
    //
    // Only release the remove lock *after* we have removed the thread entry
    // from the list because the list lifetime is tied to the FxDevice lifetime
    // and the remlock controls the lifetime of FxDevice.
    //
    // Since we never pend the wmi request, we can release the remove lock in
    // this Dispatch routine.  If we ever pended the IRPs, this would have to
    // have some more logic involved.
    //
    IoReleaseRemoveLock(
        &FxDevice::_GetFxWdmExtension(m_Device->GetDeviceObject())->IoRemoveLock,
        Irp
        );
 
    return status;
}

◆ FindProviderLocked()

_Must_inspect_result_ FxWmiProvider * FxWmiIrpHandler::FindProviderLocked ( __in LPGUID Guid )

protected

Definition at line 582 of file fxwmiirphandler.cpp.

{
    FxWmiProvider* pFound;
    PLIST_ENTRY ple;
 
    pFound = NULL;
 
    for (ple = m_ProvidersListHead.Flink;
         ple != &m_ProvidersListHead;
         ple = ple->Flink) {
 
        FxWmiProvider* pProvider;
 
        pProvider = CONTAINING_RECORD(ple, FxWmiProvider, m_ListEntry);
 
        if (RtlCompareMemory(&pProvider->m_Guid,
                             Guid,
                             sizeof(GUID)) == sizeof(GUID)) {
            pFound = pProvider;
            break;
        }
    }
 
    return pFound;
}

Referenced by AddPowerPolicyProviderAndInstance(), AddProvider(), Dispatch(), and FindProviderReferenced().

◆ FindProviderReferenced()

_Must_inspect_result_ FxWmiProvider * FxWmiIrpHandler::FindProviderReferenced	(	__in LPGUID	Guid,
		__in PVOID	Tag
	)

protected

Definition at line 612 of file fxwmiirphandler.cpp.

{
    FxWmiProvider* pProvider;
    KIRQL irql;
 
    Lock(&irql);
    pProvider = FindProviderLocked(Guid);
    if (pProvider != NULL) {
        pProvider->ADDREF(Tag);
    }
    Unlock(irql);
 
    return pProvider;
}

◆ HandleWmiTraceRequest()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::HandleWmiTraceRequest	(	__in PIRP	Irp,
		__in FxTraceInfo *	Info
	)

◆ IncrementUpdateCount()

VOID FxWmiIrpHandler::IncrementUpdateCount ( )

inlineprivate

Definition at line 265 of file fxwmiirphandler.hpp.

                           {
        LONG count;
 
        count = InterlockedIncrement(&m_UpdateCount);
        ASSERT(count > 1);
        UNREFERENCED_PARAMETER(count);
    }

Referenced by DeferUpdateLocked().

◆ PostCreateDeviceInitialize()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::PostCreateDeviceInitialize ( VOID )

Definition at line 114 of file fxwmiirphandler.cpp.

{
    m_WorkItem = IoAllocateWorkItem(GetDevice()->GetDeviceObject());
    if (m_WorkItem == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    return STATUS_SUCCESS;
}

◆ Register()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::Register ( VOID )

Definition at line 128 of file fxwmiirphandler.cpp.

{
    NTSTATUS status;
    KIRQL irql;
 
    //
    // We rely on the PnP state machine to manage our state transitions properly
    // so that we don't have to do any state checking here.
    //
    Lock(&irql);
    ASSERT(m_RegisteredState == WmiUnregistered ||
              m_RegisteredState == WmiDeregistered);
    m_RegisteredState = WmiRegistered;
    Unlock(irql);
 
    status = IoWMIRegistrationControl(GetDevice()->GetDeviceObject(),
                                      WMIREG_ACTION_REGISTER);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
            "could not register WMI with OS, %!STATUS!", status);
 
        Lock(&irql);
        m_RegisteredState = WmiUnregistered;
        Unlock(irql);
    }
 
    return status;
}

◆ RemoveProvider()

VOID FxWmiIrpHandler::RemoveProvider ( __in FxWmiProvider * Provider )

protected

Definition at line 555 of file fxwmiirphandler.cpp.

{
    KIRQL irql;
 
    //
    // No need to update via IoWMIRegistrationControl because this is only
    // called in the error path of creating a provider.
    //
    Lock(&irql);
    RemoveProviderLocked(Provider);
    Unlock(irql);
}

Referenced by FxWmiProvider::_Create(), and FxWmiProvider::Dispose().

◆ RemoveProviderLocked()

VOID FxWmiIrpHandler::RemoveProviderLocked ( __in FxWmiProvider * Provider )

protected

Definition at line 571 of file fxwmiirphandler.cpp.

{
    m_NumProviders--;
    RemoveEntryList(&Provider->m_ListEntry);
    InitializeListHead(&Provider->m_ListEntry);
}

Referenced by AddPowerPolicyProviderAndInstance(), and RemoveProvider().

◆ ResetStateForPdoRestart()

VOID FxWmiIrpHandler::ResetStateForPdoRestart ( VOID )

Definition at line 228 of file fxwmiirphandler.cpp.

{
    KIRQL irql;
 
    Lock(&irql);
 
    //
    // We can reach this state in 2 ways:
    // 1. PDO went through Init->Started->Removed->Started transition
    // 2. PDO went through Init-><SomeFailedState>->Started state (e.g.
    // Init->Ejected->EjectFailed->Started) transition.
    //
    // So, WMI registration state would either be Deregistered due to #1
    // or, Unregistered due to #2. Also, update count would be 0 in case of #1
    // and 1 in case of #2.
    //
    ASSERT(m_RegisteredState == WmiUnregistered ||
              m_RegisteredState == WmiDeregistered);
    ASSERT(m_UpdateCount == 0 || m_UpdateCount == 1);
 
    //
    // Update count is biased to 1 when created so do the same here.
    //
    m_UpdateCount = 1;
    m_UpdateEvent.Initialize();
    Unlock(irql);
}

◆ UpdateGuids()

VOID FxWmiIrpHandler::UpdateGuids ( VOID )

private

Definition at line 369 of file fxwmiirphandler.cpp.

{
    NTSTATUS status;
 
    status = IoWMIRegistrationControl(GetDevice()->GetDeviceObject(),
                                      WMIREG_ACTION_UPDATE_GUIDS);
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIO,
            "IoWMIRegistrationControl DevObj %p, for UpdateGuids failed, %!STATUS!",
            GetDevice()->GetDeviceObject(), status);
 
        //
        // Just drop the error
        //
    }
 
    //
    // The caller incremented the update count when it decided to do the update.
    // Decrement the count now that we have completed registration update.
    //
    DecrementUpdateCount();
}

Referenced by FxWmiProvider::_Create(), FxWmiProvider::AddInstance(), AddPowerPolicyProviderAndInstance(), and FxWmiProvider::RemoveInstance().

Member Data Documentation

◆ _UpdateGuids

VOID FxWmiIrpHandler::_UpdateGuids

staticprivate

Definition at line 257 of file fxwmiirphandler.hpp.

Referenced by DeferUpdateLocked().

◆ FxWmiProvider

friend FxWmiIrpHandler::FxWmiProvider

private

Definition at line 45 of file fxwmiirphandler.hpp.

Referenced by AddPowerPolicyProviderAndInstance().

◆ m_NumProviders

ULONG FxWmiIrpHandler::m_NumProviders

protected

Definition at line 305 of file fxwmiirphandler.hpp.

Referenced by _RegInfo(), AddProviderLocked(), and RemoveProviderLocked().

◆ m_ProvidersListHead

LIST_ENTRY FxWmiIrpHandler::m_ProvidersListHead

protected

Definition at line 303 of file fxwmiirphandler.hpp.

Referenced by AddProviderLocked(), FindProviderLocked(), FxWmiIrpHandler(), and ~FxWmiIrpHandler().

◆ m_RegisteredState

WmiRegisteredState FxWmiIrpHandler::m_RegisteredState

protected

Definition at line 307 of file fxwmiirphandler.hpp.

Referenced by FxWmiProvider::AddInstanceLocked(), AddProviderLocked(), Cleanup(), Deregister(), Register(), FxWmiProvider::RemoveInstance(), ResetStateForPdoRestart(), and ~FxWmiIrpHandler().

◆ m_UpdateCount

LONG FxWmiIrpHandler::m_UpdateCount

protected

Definition at line 314 of file fxwmiirphandler.hpp.

Referenced by DecrementUpdateCount(), IncrementUpdateCount(), and ResetStateForPdoRestart().

◆ m_UpdateEvent

FxCREvent FxWmiIrpHandler::m_UpdateEvent

protected

Definition at line 320 of file fxwmiirphandler.hpp.

Referenced by DecrementUpdateCount(), DecrementUpdateCountAndWait(), and ResetStateForPdoRestart().

◆ m_WmiDispatchTable

const FxWmiMinorEntry FxWmiIrpHandler::m_WmiDispatchTable

staticprotected

Definition at line 301 of file fxwmiirphandler.hpp.

Referenced by CheckAssumptions(), and Dispatch().

◆ m_WorkItem

PIO_WORKITEM FxWmiIrpHandler::m_WorkItem

protected

Definition at line 309 of file fxwmiirphandler.hpp.

Referenced by DeferUpdateLocked(), PostCreateDeviceInitialize(), and ~FxWmiIrpHandler().

◆ m_WorkItemEvent

PKEVENT FxWmiIrpHandler::m_WorkItemEvent

protected

Definition at line 322 of file fxwmiirphandler.hpp.

Referenced by Deregister().

◆ m_WorkItemQueued

BOOLEAN FxWmiIrpHandler::m_WorkItemQueued

protected

Definition at line 324 of file fxwmiirphandler.hpp.

Referenced by DeferUpdateLocked(), and Deregister().

The documentation for this class was generated from the following files:

sdk/lib/drivers/wdf/shared/inc/private/common/fxwmiirphandler.hpp
sdk/lib/drivers/wdf/kmdf/src/irphandlers/wmi/fxwmiirphandler.cpp
sdk/lib/drivers/wdf/shared/irphandlers/pnp/um/fxwmiirphandlerum.cpp

Private Member Functions
VOID	CompleteWmiQueryAllDataRequest (__in PIRP Irp, __in NTSTATUS Status, __in ULONG BufferUsed)

VOID	CompleteWmiQuerySingleInstanceRequest (__in PIRP Irp, __in NTSTATUS Status, __in ULONG BufferUsed)

VOID	CompleteWmiExecuteMethodRequest (__in PIRP Irp, __in NTSTATUS Status, __in ULONG BufferUsed)

_Must_inspect_result_ NTSTATUS	CompleteWmiRequest (__in PIRP Irp, __in NTSTATUS Status, __in ULONG BufferUsed)

BOOLEAN	DeferUpdateLocked (__in KIRQL OldIrql)

VOID	UpdateGuids (VOID)

VOID	IncrementUpdateCount ()

VOID	DecrementUpdateCount ()

VOID	DecrementUpdateCountAndWait ()

Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ WmiRegisteredState

Constructor & Destructor Documentation

◆ FxWmiIrpHandler()

◆ ~FxWmiIrpHandler()

Member Function Documentation

◆ _ChangeSingleInstance()

◆ _ChangeSingleItem()

◆ _EnableDisableEventsAndCollection()

◆ _ExecuteMethod()

◆ _QueryAllData()

◆ _QuerySingleInstance()

◆ _RegInfo()

◆ AddPowerPolicyProviderAndInstance()

◆ AddProvider()

◆ AddProviderLocked()

◆ CheckAssumptions()

◆ Cleanup()

◆ CompleteWmiExecuteMethodRequest()

◆ CompleteWmiQueryAllDataRequest()

◆ CompleteWmiQuerySingleInstanceRequest()

◆ CompleteWmiRequest()

◆ DecrementUpdateCount()

◆ DecrementUpdateCountAndWait()

◆ DeferUpdateLocked()

◆ Deregister()

◆ Dispatch()

◆ FindProviderLocked()

◆ FindProviderReferenced()

◆ HandleWmiTraceRequest()

◆ IncrementUpdateCount()

◆ PostCreateDeviceInitialize()

◆ Register()

◆ RemoveProvider()

◆ RemoveProviderLocked()

◆ ResetStateForPdoRestart()

◆ UpdateGuids()

Member Data Documentation

◆ _UpdateGuids

◆ FxWmiProvider

◆ m_NumProviders

◆ m_ProvidersListHead

◆ m_RegisteredState

◆ m_UpdateCount

◆ m_UpdateEvent

◆ m_WmiDispatchTable

◆ m_WorkItem

◆ m_WorkItemEvent

◆ m_WorkItemQueued