ReactOS  0.4.15-dev-3297-g037c744
FxWmiIrpHandler Class Reference

#include <fxwmiirphandler.hpp>

Inheritance diagram for FxWmiIrpHandler:
Collaboration diagram for FxWmiIrpHandler:

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 CfxDeviceGetDevice (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 FxContextHeaderGetContextHeader (VOID)
 
__inline PFX_DRIVER_GLOBALS GetDriverGlobals (VOID)
 
WDFTYPE GetType (VOID)
 
USHORT GetObjectSize (VOID)
 
LONG GetRefCnt (VOID)
 
FxTagTrackerGetTagTracker (VOID)
 
CfxDeviceGetDevice (VOID)
 
CfxDeviceBaseGetDeviceBase (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_ FxObjectGetParentObjectReferenced (__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_ FxWmiProviderFindProviderLocked (__in LPGUID Guid)
 
_Must_inspect_result_ FxWmiProviderFindProviderReferenced (__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)
 
FxObjectDebugExtensionGetDebugExtension (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 []
 

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

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

Enumerator
WmiUnregistered 
WmiRegistered 
WmiDeregistered 
WmiCleanedUp 

Definition at line 293 of file fxwmiirphandler.hpp.

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.

87  :
88  FxPackage(FxDriverGlobals, Device, Type),
91  m_UpdateCount(1) // bias m_UpdateCount to 1, Deregister routine will
92  // decrement this.
93 {
95 }
WmiRegisteredState m_RegisteredState
#define FALSE
Definition: types.h:117
LIST_ENTRY m_ProvidersListHead
Type
Definition: Type.h:6
FxPackage(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in CfxDevice *Device, __in WDFTYPE Type)
Definition: fxpackage.cpp:31
PIO_WORKITEM m_WorkItem
_Must_inspect_result_ _In_ WDFDEVICE Device
Definition: wdfchildlist.h:474
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define NULL
Definition: types.h:112

◆ ~FxWmiIrpHandler()

FxWmiIrpHandler::~FxWmiIrpHandler ( )

Definition at line 97 of file fxwmiirphandler.cpp.

98 {
99  //
100  // If the device could not get past AddDevice or failed the initial start
101  // device, we will be unregistered. Otherwise we should be cleaned up.
102  //
104 
106 
107  if (m_WorkItem != NULL) {
109  }
110 }
WmiRegisteredState m_RegisteredState
VOID NTAPI IoFreeWorkItem(IN PIO_WORKITEM IoWorkItem)
Definition: iowork.c:64
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
#define ASSERT(a)
Definition: mode.c:44
LIST_ENTRY m_ProvidersListHead
PIO_WORKITEM m_WorkItem
#define NULL
Definition: types.h:112

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.

1303 {
1304  PWNODE_SINGLE_INSTANCE pSingle;
1306  NTSTATUS status;
1307  ULONG size;
1308 
1309  size = 0;
1310 
1312  pSingle = (PWNODE_SINGLE_INSTANCE) stack->Parameters.WMI.Buffer;
1313 
1314  if (Instance->IsSetInstanceSupported() == FALSE) {
1316  }
1317  else if (pSingle->SizeDataBlock < Provider->m_MinInstanceBufferSize) {
1318  size = Provider->m_MinInstanceBufferSize;
1320  }
1321  else {
1323  }
1324 
1325  if (NT_SUCCESS(status)) {
1326  size = pSingle->SizeDataBlock;
1327 
1328  status = Instance->SetInstance(
1329  pSingle->SizeDataBlock,
1330  size == 0 ?
1331  NULL : WDF_PTR_ADD_OFFSET(pSingle, pSingle->DataBlockOffset)
1332  );
1333 
1335  if (status == STATUS_PENDING) {
1337  size = 0;
1338  }
1339  }
1340 
1341  status = This->CompleteWmiRequest(Irp, status, size);
1342 
1343  return status;
1344 }
struct tagWNODE_SINGLE_INSTANCE * PWNODE_SINGLE_INSTANCE
#define WDF_PTR_ADD_OFFSET(_ptr, _offset)
Definition: wdfcore.h:144
LONG NTSTATUS
Definition: precomp.h:26
static stack_node_t * stack
Definition: rpn_ieee.c:37
#define STATUS_WMI_READ_ONLY
Definition: ntstatus.h:818
if(dx==0 &&dy==0)
Definition: linetemp.h:174
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
Definition: _stack.h:47
GLsizeiptr size
Definition: glext.h:5919
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
#define NULL
Definition: types.h:112
unsigned int ULONG
Definition: retypes.h:1
#define STATUS_SUCCESS
Definition: shellext.h:65
static SERVICE_STATUS status
Definition: service.c:31
IN PVOID Instance
Definition: pci.h:361
Definition: ps.c:97

◆ _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.

1354 {
1355  PWNODE_SINGLE_ITEM pSingle;
1356  NTSTATUS status;
1357  ULONG size;
1358 
1360 
1361  size = 0;
1362 
1364  Parameters.WMI.Buffer;
1365 
1366  if (Instance->IsSetItemSupported() == FALSE) {
1368  }
1369  else {
1371  }
1372 
1373  if (NT_SUCCESS(status)) {
1374  status = Instance->SetItem(
1375  pSingle->ItemId,
1376  pSingle->SizeDataItem,
1377  pSingle->SizeDataItem == 0 ?
1378  NULL : WDF_PTR_ADD_OFFSET(pSingle, pSingle->DataBlockOffset)
1379  );
1380 
1382  if (status == STATUS_PENDING) {
1384  size = 0;
1385  }
1386  }
1387 
1388  status = This->CompleteWmiRequest(Irp, status, size);
1389 
1390  return status;
1391 }
ULONG DataBlockOffset
Definition: wmistr.h:129
struct tagWNODE_SINGLE_ITEM * PWNODE_SINGLE_ITEM
_Must_inspect_result_ _In_ WDFQUEUE _In_opt_ WDFREQUEST _In_opt_ WDFFILEOBJECT _Inout_opt_ PWDF_REQUEST_PARAMETERS Parameters
Definition: wdfio.h:863
#define WDF_PTR_ADD_OFFSET(_ptr, _offset)
Definition: wdfcore.h:144
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_WMI_READ_ONLY
Definition: ntstatus.h:818
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
struct _IO_STACK_LOCATION::@3729::@3767 WMI
GLsizeiptr size
Definition: glext.h:5919
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
#define NULL
Definition: types.h:112
unsigned int ULONG
Definition: retypes.h:1
#define STATUS_SUCCESS
Definition: shellext.h:65
static SERVICE_STATUS status
Definition: service.c:31
IN PVOID Instance
Definition: pci.h:361
Definition: ps.c:97

◆ _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.

1401 {
1402  NTSTATUS status;
1403  BOOLEAN enable;
1404  WDF_WMI_PROVIDER_CONTROL control;
1406 
1409 
1410  Irp->IoStatus.Information = 0;
1411 
1413 
1414  if (stack->Parameters.WMI.BufferSize < sizeof(WNODE_HEADER)) {
1416  goto Done;
1417  }
1418 
1419  switch (stack->MinorFunction) {
1420  case IRP_MN_ENABLE_EVENTS:
1421  enable = TRUE;
1422  control = WdfWmiEventControl;
1423  break;
1424 
1425  case IRP_MN_DISABLE_EVENTS:
1426  enable = FALSE;
1427  control = WdfWmiEventControl;
1428  break;
1429 
1431  enable = TRUE;
1432  control = WdfWmiInstanceControl;
1433  break;
1434 
1436  enable = FALSE;
1437  control = WdfWmiInstanceControl;
1438  break;
1439 
1440  default:
1441  status = Irp->IoStatus.Status;
1442  goto Done;
1443  }
1444 
1445  if (control == WdfWmiEventControl) {
1446  Provider->m_EventControlEnabled = enable;
1447 
1448  //
1449  // Capture the tracing information before making the callback
1450  //
1451  if (Provider->m_Flags & WdfWmiProviderTracing) {
1452  Provider->SetTracingHandle(
1453  ((PWNODE_HEADER) stack->Parameters.WMI.Buffer)->HistoricalContext
1454  );
1455  }
1456  }
1457  else {
1458  Provider->m_DataBlockControlEnabled = enable;
1459  }
1460 
1461  if (Provider->IsFunctionControlSupported()) {
1462  status = Provider->FunctionControl(control, enable);
1463  }
1464  else {
1466  }
1467 
1469  if (status == STATUS_PENDING) {
1471  }
1472 
1473  //
1474  // Undo the previous capture on error
1475  //
1476  if (!NT_SUCCESS(status)) {
1477  if (control == WdfWmiEventControl) {
1478  Provider->m_EventControlEnabled = FALSE;
1479 
1480  if (Provider->m_Flags & WdfWmiProviderTracing) {
1481  Provider->SetTracingHandle(NULL);
1482  }
1483  }
1484  else {
1485  Provider->m_DataBlockControlEnabled = FALSE;
1486  }
1487 
1488  }
1489 
1490 Done:
1491  Irp->IoStatus.Status = status;
1493 
1494  return status;
1495 }
#define TRUE
Definition: types.h:120
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
WDF_EXTERN_C_START enum _WDF_WMI_PROVIDER_CONTROL WDF_WMI_PROVIDER_CONTROL
LONG NTSTATUS
Definition: precomp.h:26
static stack_node_t * stack
Definition: rpn_ieee.c:37
#define IRP_MN_ENABLE_COLLECTION
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
#define IRP_MN_DISABLE_COLLECTION
unsigned char BOOLEAN
#define IoCompleteRequest
Definition: irp.c:1240
Definition: _stack.h:47
#define IRP_MN_ENABLE_EVENTS
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define IRP_MN_DISABLE_EVENTS
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
GLboolean enable
Definition: glext.h:11120
#define NULL
Definition: types.h:112
#define IO_NO_INCREMENT
Definition: iotypes.h:598
#define STATUS_SUCCESS
Definition: shellext.h:65
static SERVICE_STATUS status
Definition: service.c:31
IN PVOID Instance
Definition: pci.h:361
Definition: ps.c:97

◆ _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.

1505 {
1506  PWNODE_METHOD_ITEM pMethod;
1508  NTSTATUS status;
1509  ULONG size, inBufferSize, outBufferSize;
1510 
1513 
1514  size = 0;
1515 
1517  pMethod = (PWNODE_METHOD_ITEM) stack->Parameters.WMI.Buffer;
1518  inBufferSize = pMethod->SizeDataBlock;
1519  outBufferSize = stack->Parameters.WMI.BufferSize - pMethod->DataBlockOffset;
1520 
1521 
1522 
1523 
1524 
1525 
1526 
1527 
1528 
1529 
1530 
1531  if (Instance->IsExecuteMethodSupported() == FALSE) {
1532  //
1533  // WmiLib returns this value when there is no execute method function
1534  // pointer specified to it.
1535  //
1537  }
1538  else {
1540  }
1541 
1542  if (NT_SUCCESS(status)) {
1543  status = Instance->ExecuteMethod(
1544  pMethod->MethodId,
1545  inBufferSize,
1546  outBufferSize,
1547  (inBufferSize == 0 && outBufferSize == 0) ?
1548  NULL : WDF_PTR_ADD_OFFSET(pMethod, pMethod->DataBlockOffset),
1549  &size
1550  );
1551 
1553  if (status == STATUS_PENDING) {
1555  size = 0;
1556  }
1557  }
1558 
1559  status = This->CompleteWmiRequest(Irp, status, size);
1560 
1561  return status;
1562 }
#define WDF_PTR_ADD_OFFSET(_ptr, _offset)
Definition: wdfcore.h:144
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
ULONG DataBlockOffset
Definition: wmistr.h:140
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
static stack_node_t * stack
Definition: rpn_ieee.c:37
if(dx==0 &&dy==0)
Definition: linetemp.h:174
struct tagWNODE_METHOD_ITEM * PWNODE_METHOD_ITEM
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
Definition: _stack.h:47
GLsizeiptr size
Definition: glext.h:5919
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
#define NULL
Definition: types.h:112
unsigned int ULONG
Definition: retypes.h:1
#define STATUS_SUCCESS
Definition: shellext.h:65
static SERVICE_STATUS status
Definition: service.c:31
IN PVOID Instance
Definition: pci.h:361
Definition: ps.c:97

◆ _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.

841 {
843  PWNODE_ALL_DATA pNodeData;
845  PUCHAR pData;
846  NTSTATUS status, addStatus;
847  ULONG instanceCount, dataBlockOffset, lengthArraySize, i, sizeRemaining,
848  lastAdjustment, bufferUsed, tempOffset;
849  KIRQL irql;
850  BOOLEAN tooSmall;
851 
853 
855 
857  pNodeData = (PWNODE_ALL_DATA) stack->Parameters.WMI.Buffer;
858 
859  lastAdjustment = 0;
860  pData = NULL;
861  dataBlockOffset = 0;
862 
863  //
864  // This either the amount of buffer used on successful queries or the
865  // amount of buffer required if the buffer is not big enough.
866  //
867  bufferUsed = 0;
868 
869  tooSmall = FALSE;
870 
871  if (stack->Parameters.WMI.BufferSize < sizeof(WNODE_ALL_DATA)) {
873  goto Done;
874  }
875 
876 
877 
878 
879 
880 
881 
882  //
883  // All of the provider's access is guarded by the irp handler's lock
884  //
885  This->Lock(&irql);
886  instanceCount = Provider->m_NumInstances;
887  This->Unlock(irql);
888 
889 
890 
891 
892 
893 
894 
895 
896 
897 
898 
899  if (instanceCount == 0) {
902  This->GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
903  "Failing QueryAllData since no instances found for "
904  "WDFWMIPROVIDER %p, %!STATUS!",
905  Provider->GetHandle(), status);
906  bufferUsed = 0;
907  goto Done;
908  }
909 
911  This->GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
912  "WDFWMIPROVIDER %p QueryAllData, num instances %d",
913  Provider->GetHandle(), instanceCount);
914 
915  pNodeData->InstanceCount = instanceCount;
916 
917 
918 
919 
920 
921 
922  pNodeData->WnodeHeader.Flags &= ~WNODE_FLAG_FIXED_INSTANCE_SIZE;
923 
924  //
925  // Since value of instanceCount is not limited, do overflow-safe addition
926  // and multiplication
927  //
928  // lengthArraySize = instanceCount * sizeof(OFFSETINSTANCEDATAANDLENGTH);
929  status = RtlULongMult(instanceCount,
931  &lengthArraySize);
932 
933  if (NT_SUCCESS(status)) {
934  // dataBlockOffset =
935  // FIELD_OFFSET(WNODE_ALL_DATA, OffsetInstanceDataAndLength) + lengthArraySize;
936  status = RtlULongAdd(
937  FIELD_OFFSET(WNODE_ALL_DATA, OffsetInstanceDataAndLength),
938  lengthArraySize,
939  &tempOffset);
940 
941  if (NT_SUCCESS(status)) {
942  dataBlockOffset = (ULONG) WDF_ALIGN_SIZE_UP(
943  tempOffset, MEMORY_ALLOCATION_ALIGNMENT);
944 
945  if (dataBlockOffset < tempOffset) {
947  }
948  }
949  }
950 
951  if (!NT_SUCCESS(status)) {
953  This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
954  "Failing QueryAllData since integer overflow occured using"
955  " provider instance count %d for WDFWMIPROVIDER %p, %!STATUS!",
956  instanceCount, Provider->GetHandle(), status);
957  bufferUsed = 0;
958  goto Done;
959  }
960 
961  pNodeData->DataBlockOffset = dataBlockOffset;
962 
963  if (dataBlockOffset <= stack->Parameters.WMI.BufferSize) {
964  pOffsets = &pNodeData->OffsetInstanceDataAndLength[0];
965  sizeRemaining = stack->Parameters.WMI.BufferSize - dataBlockOffset;
966  pData = (PUCHAR) WDF_PTR_ADD_OFFSET(pNodeData, dataBlockOffset);
967  }
968  else {
969  //
970  // There is not enough room in the WNODE to complete the query, but
971  // we still want to query all the instances to see how big a buffer the
972  // caller should resend.
973  //
974  pOffsets = NULL;
975  pData = NULL;
976  sizeRemaining = 0;
977 
978  //
979  // We are in the too small case
980  //
981  tooSmall = TRUE;
983  }
984 
985  if (instanceCount > 0 && Provider->GetMinInstanceBufferSize() != 0) {
986  ULONG size, minSizeAdjusted;
987 
988  size = 0;
989 
990  minSizeAdjusted = (ULONG) WDF_ALIGN_SIZE_UP(
991  Provider->GetMinInstanceBufferSize(),
993  );
994 
995  //
996  // Quick size check to make sure there is enough buffer for all of the
997  // instances. We round up all but the last instance's minimum size so
998  // that we can make sure we have enough room for an aligned bufer for
999  // each instance.
1000  //
1001  // All but the last instance are using the adjusted size. In the end,
1002  // we will have:
1003  //
1004  // size = minSizeAdjusted * (instanceCount-1) +
1005  // Provider->GetMinInstanceBufferSize();
1006  //
1007  // NOTE: we do not care about instances which do not support query
1008  // data. We don't care b/c by computing the total size of all
1009  // instances we compute the maximum sized buffer needed, and if
1010  // a few instances do no support query data, then the buffer
1011  // will just be too large, never too small.
1012  //
1013  status = RtlULongMult(minSizeAdjusted, instanceCount - 1, &size);
1014  if (!NT_SUCCESS(status)) {
1015  goto Done;
1016  }
1017 
1018  status = RtlULongAdd(size, Provider->GetMinInstanceBufferSize(), &size);
1019  if (!NT_SUCCESS(status)) {
1020  goto Done;
1021  }
1022 
1023  //
1024  // Since the client indicated that that each block as a minimum instance
1025  // size (which in reality is the fixed size, variable sized instnaces
1026  // should report a minimum instance size of zero), we can compute the
1027  // required buffer size w/out querying each instance for the required
1028  // size.
1029  //
1030  if (sizeRemaining < size) {
1031  //
1032  // bufferUsed in the buffer too small case indicates how many bytes
1033  // we want the caller to allocate.
1034  //
1035  bufferUsed = size;
1037  goto Done;
1038  }
1039  }
1040 
1041  for (i = 0; i < instanceCount; i++) {
1043 
1044  //
1045  // In the case where we have a minimum instance size, we should have
1046  // verified correctly above to have enough buffer.
1047  //
1048  ASSERT(sizeRemaining >= Provider->GetMinInstanceBufferSize());
1049 
1050  pInstance = Provider->GetInstanceReferenced(i, Irp);
1051 
1052  if (pInstance == NULL) {
1053  break;
1054  }
1055 
1057  ULONG tmpSize;
1058 
1059  tmpSize = 0;
1060 
1061  status = pInstance->QueryInstance(sizeRemaining, pData, &tmpSize);
1062 
1064  ULONG adjustedSize;
1065 
1066  //
1067  // We calculate the size in both cases. In the NT_SUCCESS case,
1068  // it is the amount of buffer used. In the too small case, it is
1069  // the amount of buffer required for a subsequent query.
1070  //
1071  adjustedSize = (ULONG) WDF_ALIGN_SIZE_UP(
1073  );
1074 
1075  if (adjustedSize < tmpSize) {
1076  //
1077  // Overflow, adjustedSize will be >= tmpSize in the normal
1078  // case.
1079  //
1082  This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
1083  "WDFWMIINSTNACE %p queried, returned a buffer size of %d,"
1084  "but it could not be rounded up, %!STATUS!",
1085  pInstance->GetHandle(), tmpSize, status);
1086  goto QueryError;
1087  }
1088 
1089  //
1090  // Keep track of how much we adjusted up the size on the last
1091  // instance so that when compute the total buffer used, we
1092  // do not include the final size adjustment.
1093  //
1094  lastAdjustment = adjustedSize - tmpSize;
1095 
1096  //
1097  // We only write the offset and data if we have not yet
1098  // encountered an instance where the buffer size was too small.
1099  //
1100  if (NT_SUCCESS(status) && tooSmall == FALSE) {
1101  //
1102  // dataBlockOffset is where we are currently at in the buffer
1103  //
1104  pOffsets[i].LengthInstanceData = tmpSize;
1105  pOffsets[i].OffsetInstanceData = dataBlockOffset;
1106 
1107  pData += adjustedSize;
1108  }
1109  else {
1110  tooSmall = TRUE;
1111  }
1112 
1113  //
1114  // Compute how much buffer we have left and our offset into it.
1115  //
1116  if (adjustedSize <= sizeRemaining) {
1117  sizeRemaining -= adjustedSize;
1118 
1119  //
1120  // dataBlockOffset += adjustedSize;
1121  //
1122  addStatus = RtlULongAdd(dataBlockOffset,
1123  adjustedSize,
1124  &dataBlockOffset);
1125  }
1126  else {
1127  //
1128  // dataBlockOffset += sizeRemaining;
1129  //
1130  addStatus = RtlULongAdd(dataBlockOffset,
1131  sizeRemaining,
1132  &dataBlockOffset);
1133  sizeRemaining = 0;
1134  }
1135 
1136  if (!NT_SUCCESS(addStatus)) {
1137  status = addStatus;
1139  This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
1140  "WDFWMIPROVIDER %p, arithmetic overflow in computing "
1141  "block offset, %!STATUS!", Provider->GetHandle(),
1142  status);
1143  goto QueryError;
1144  }
1145 
1146  //
1147  // Compute how much buffer space we have used or require the
1148  // caller to provide. This is just the count of bytes for the
1149  // data queried, it does not yet include the array size required
1150  // to report offset & lengths.
1151  //
1152  // bufferUsed += adjustedSize;
1153  //
1154  addStatus = RtlULongAdd(bufferUsed, adjustedSize, &bufferUsed);
1155 
1156  if (!NT_SUCCESS(addStatus)) {
1157  status = addStatus;
1159  This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
1160  "WDFWMIPROVIDER %p, arithmetic overflow in computing "
1161  "buffer consumed(%d+%d), %!STATUS!",
1162  Provider->GetHandle(), bufferUsed, adjustedSize, status);
1163  goto QueryError;
1164  }
1165  }
1166  }
1167  else if (pOffsets != NULL) {
1168  //
1169  // Indicate no buffer and the current offset. If there any
1170  // other instances after this one, they will share the same
1171  // offset.
1172  //
1173  pOffsets[i].LengthInstanceData = 0;
1174  pOffsets[i].OffsetInstanceData = dataBlockOffset;
1175  }
1176 
1177 QueryError:
1178  pInstance->RELEASE(Irp);
1179 
1180  //
1181  // We continue on STATUS_BUFFER_TOO_SMALL so that we can ask each
1182  // instance the amount of buffer it needs.
1183  //
1185  break;
1186  }
1187  }
1188 
1189  //
1190  // We can have STATUS_BUFFER_TOO_SMALL if the last instance could not fit
1191  // its data into the buffer or have success if the last instance could write
1192  // its data, but a previous instance could not.
1193  //
1194  if (status == STATUS_BUFFER_TOO_SMALL || (NT_SUCCESS(status) && tooSmall)) {
1195  //
1196  // Since we align up the size of each block to MEMORY_ALLOCATION_ALIGNMENT,
1197  // the total buffer size is possibly adjusted up too high. Subtract the
1198  // last adjustment made for alignment when computing the instance size
1199  // so that our total size is not rounded up.
1200  //
1201  // CompleteWmiQueryAllDataRequest will take care of adding enough space
1202  // to the requested size to account for the array of instance offsets
1203  // and lengths.
1204  //
1205  bufferUsed -=lastAdjustment;
1206 
1208 
1210  This->GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGPNP,
1211  "WDFWMIPROVIDER %p QueryAllData returning %!STATUS!, requesting "
1212  "buffer size of 0x%x", Provider->GetHandle(), status, bufferUsed);
1213  }
1214  else if (NT_SUCCESS(status)) {
1215  //
1216  // Compute the total amount of buffer used. dataBlockOffset is the
1217  // offset of the next instance, which is one past the end, so just
1218  // compute the distance from the start.
1219  //
1220  // Since align up the size of each block to MEMORY_ALLOCATION_ALIGNMENT,
1221  // the total buffer size is possibly adjusted up too high. Subtract the
1222  // last adjustment made for alignment when computing the instance size
1223  // so that our total size is not rounded up.
1224  //
1225  ASSERT(dataBlockOffset >= pNodeData->DataBlockOffset);
1226  ASSERT(dataBlockOffset - pNodeData->DataBlockOffset >= lastAdjustment);
1227  bufferUsed = dataBlockOffset - pNodeData->DataBlockOffset - lastAdjustment;
1228  }
1229  else {
1231  This->GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
1232  "WDFWMIPROVIDER %p QueryAllData returning %!STATUS!",
1233  Provider->GetHandle(), status);
1234 
1235  bufferUsed = 0;
1236  }
1237 
1239  This->GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGPNP,
1240  "WDFWMIPROVIDER %p QueryAllData returning %!STATUS!, buffer used 0x%x",
1241  Provider->GetHandle(), status, bufferUsed);
1242 
1243 Done:
1244  status = This->CompleteWmiRequest(Irp, status, bufferUsed);
1245 
1246  return status;
1247 }
OFFSETINSTANCEDATAANDLENGTH OffsetInstanceDataAndLength[0]
Definition: wmistr.h:119
struct tagWNODE_ALL_DATA * PWNODE_ALL_DATA
_Must_inspect_result_ _In_ WDFQUEUE _In_opt_ WDFREQUEST _In_opt_ WDFFILEOBJECT _Inout_opt_ PWDF_REQUEST_PARAMETERS Parameters
Definition: wdfio.h:863
#define WDF_PTR_ADD_OFFSET(_ptr, _offset)
Definition: wdfcore.h:144
#define TRUE
Definition: types.h:120
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
unsigned char * PUCHAR
Definition: retypes.h:3
LONG NTSTATUS
Definition: precomp.h:26
KIRQL irql
Definition: wave.h:1
static stack_node_t * stack
Definition: rpn_ieee.c:37
if(dx==0 &&dy==0)
Definition: linetemp.h:174
#define TRACE_LEVEL_INFORMATION
Definition: storswtr.h:29
#define STATUS_WMI_INSTANCE_NOT_FOUND
Definition: ntstatus.h:777
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
#define TRACE_LEVEL_VERBOSE
Definition: storswtr.h:30
#define STATUS_INTEGER_OVERFLOW
Definition: ntstatus.h:385
FORCEINLINE size_t WDF_ALIGN_SIZE_UP(_In_ size_t Length, _In_ size_t AlignTo)
Definition: wdfcore.h:129
unsigned char BOOLEAN
Definition: _stack.h:47
ULONG DataBlockOffset
Definition: wmistr.h:113
GLsizeiptr size
Definition: glext.h:5919
#define WNODE_FLAG_FIXED_INSTANCE_SIZE
Definition: wmistr.h:32
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
virtual BOOLEAN IsQueryInstanceSupported(VOID)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define TRACE_LEVEL_ERROR
Definition: storswtr.h:27
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
#define TRACINGPNP
Definition: dbgtrace.h:67
FxWmiInstanceExternal * pInstance
Definition: fxwmiapi.cpp:113
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
#define NULL
Definition: types.h:112
WDFWMIINSTANCE GetHandle(VOID)
unsigned int ULONG
Definition: retypes.h:1
struct _WNODE_HEADER WnodeHeader
Definition: wmistr.h:112
#define STATUS_SUCCESS
Definition: shellext.h:65
TW_UINT32 TW_UINT16 TW_UINT16 TW_MEMREF pData
Definition: twain.h:1827
static SERVICE_STATUS status
Definition: service.c:31
ULONG InstanceCount
Definition: wmistr.h:114
#define MEMORY_ALLOCATION_ALIGNMENT
Definition: ntbasedef.h:90
IN PVOID Instance
Definition: pci.h:361
Definition: ps.c:97

◆ _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.

1257 {
1258  PWNODE_SINGLE_INSTANCE pSingle;
1260  NTSTATUS status;
1262 
1263  size = 0;
1264 
1266  pSingle = (PWNODE_SINGLE_INSTANCE) stack->Parameters.WMI.Buffer;
1267  bufferSize = stack->Parameters.WMI.BufferSize - pSingle->DataBlockOffset;
1268 
1269  if (Instance->IsQueryInstanceSupported() == FALSE) {
1271  }
1272  else if (bufferSize < Provider->GetMinInstanceBufferSize()) {
1273  size = Provider->GetMinInstanceBufferSize();
1275  }
1276  else {
1278  }
1279 
1280  if (NT_SUCCESS(status)) {
1281  status = Instance->QueryInstance(
1282  bufferSize,
1283  WDF_PTR_ADD_OFFSET(pSingle, pSingle->DataBlockOffset),
1284  &size
1285  );
1286 
1287  pSingle->SizeDataBlock = size;
1288  }
1289 
1290  status = This->CompleteWmiRequest(Irp, status, size);
1291 
1292  return status;
1293 }
struct tagWNODE_SINGLE_INSTANCE * PWNODE_SINGLE_INSTANCE
#define WDF_PTR_ADD_OFFSET(_ptr, _offset)
Definition: wdfcore.h:144
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
static stack_node_t * stack
Definition: rpn_ieee.c:37
if(dx==0 &&dy==0)
Definition: linetemp.h:174
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
Definition: _stack.h:47
GLsizeiptr size
Definition: glext.h:5919
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
size_t bufferSize
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
unsigned int ULONG
Definition: retypes.h:1
#define STATUS_SUCCESS
Definition: shellext.h:65
static SERVICE_STATUS status
Definition: service.c:31
IN PVOID Instance
Definition: pci.h:361
Definition: ps.c:97

◆ _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.

1572 {
1574  PUNICODE_STRING pRegPath;
1575  PWMIREGINFO pWmiRegInfo;
1576  PUCHAR pBuffer;
1577  PUNICODE_STRING pMofString;
1578  FxDevice* pDevice;
1579  NTSTATUS status;
1580  ULONG registryPathOffset, mofResourceOffset, bufferNeeded, information,
1581  bufferSize;
1582  KIRQL irql;
1583 
1586 
1587  information = 0;
1588 
1590  pBuffer = (PUCHAR) stack->Parameters.WMI.Buffer;
1591  bufferSize = stack->Parameters.WMI.BufferSize;
1592 
1593  pDevice = This->m_Device;
1594 
1595  This->Lock(&irql);
1596 
1597  mofResourceOffset = sizeof(WMIREGINFO) +
1598  This->m_NumProviders * sizeof(WMIREGGUIDW);
1599 
1600  pMofString = NULL;
1601 
1603  pMofString = &pDevice->m_MofResourceName;
1604  }
1605  else {
1606  //
1607  // Start with the parent and iterate up until we hit a device without
1608  // a parent.
1609  //
1611 
1612  while (pDevice != NULL) {
1614  pMofString = &pDevice->m_MofResourceName;
1615  break;
1616  }
1617 
1618  //
1619  // Advance to the next ancestor
1620  //
1622  }
1623 
1624  //
1625  // Restore pDevice back to this device
1626  //
1627  pDevice = This->m_Device;
1628  }
1629 
1631 
1632  //
1633  // if there is a mof string, add its length. We always need to at least
1634  // add the USHORT to indicate a string of size 0.
1635  //
1636  registryPathOffset = mofResourceOffset + sizeof(USHORT);
1637  if (pMofString != NULL) {
1638  registryPathOffset += pMofString->Length;
1639  }
1640 
1641  //
1642  // eventually bufferNeeded = registryPathOffset + pRegPath->Length +
1643  // sizeof(USHORT)
1644  //
1645  status = RtlULongAdd(registryPathOffset, pRegPath->Length, &bufferNeeded);
1646  if (!NT_SUCCESS(status)) {
1647  goto Done;
1648  }
1649 
1650  status = RtlULongAdd(bufferNeeded, sizeof(USHORT), &bufferNeeded);
1651  if (!NT_SUCCESS(status)) {
1652  goto Done;
1653  }
1654 
1655  if (bufferNeeded <= bufferSize) {
1656  PLIST_ENTRY ple;
1657  ULONG i;
1658  BOOLEAN addref;
1659 
1660  information = bufferNeeded;
1661 
1662  pWmiRegInfo = (PWMIREGINFO) pBuffer;
1663  pWmiRegInfo->BufferSize = bufferNeeded;
1664  pWmiRegInfo->NextWmiRegInfo = 0;
1665  pWmiRegInfo->MofResourceName = mofResourceOffset;
1666  pWmiRegInfo->RegistryPath = registryPathOffset;
1667  pWmiRegInfo->GuidCount = This->m_NumProviders;
1668 
1670  ? TRUE : FALSE;
1671 
1672  for (ple = This->m_ProvidersListHead.Flink, i = 0;
1673  i < This->m_NumProviders;
1674  ple = ple->Flink, i++) {
1675 
1676  PWMIREGGUIDW pWmiRegGuid;
1677  PDEVICE_OBJECT pdo;
1679 
1680  pProvider = CONTAINING_RECORD(ple, FxWmiProvider, m_ListEntry);
1681 
1682  pWmiRegGuid = &pWmiRegInfo->WmiRegGuid[i];
1683 
1684  RtlCopyMemory(&pWmiRegGuid->Guid,
1685  &pProvider->m_Guid,
1686  sizeof(GUID));
1687 
1688  pWmiRegGuid->InstanceCount = pProvider->m_NumInstances;
1689 
1690  pWmiRegGuid->Flags = pProvider->GetRegistrationFlagsLocked();
1691 
1692  pdo = pDevice->GetPhysicalDevice();
1693  pWmiRegGuid->Pdo = (ULONG_PTR) pdo;
1694 
1695  if (addref) {
1696  ObReferenceObject(pdo);
1697  }
1698  }
1699  }
1700  else {
1701  *((PULONG) pBuffer) = bufferNeeded;
1702  information = sizeof(ULONG);
1703  }
1704 
1705  This->Unlock(irql);
1706 
1707  //
1708  // Must copy the strings outside of any lock since they are in paged pool
1709  //
1710  if (bufferNeeded <= bufferSize) {
1711  PUSHORT pLength;
1712 
1713  pLength = WDF_PTR_ADD_OFFSET_TYPE(pBuffer, mofResourceOffset, PUSHORT);
1714 
1715  if (pMofString != NULL) {
1716  *pLength = pMofString->Length;
1717 
1718  RtlCopyMemory(pLength + 1,
1719  pMofString->Buffer,
1720  pMofString->Length);
1721  }
1722  else {
1723  *pLength = 0;
1724  }
1725 
1726  pLength = WDF_PTR_ADD_OFFSET_TYPE(pBuffer, registryPathOffset, PUSHORT);
1727 
1728  *pLength = pRegPath->Length;
1729  RtlCopyMemory(pLength + 1,
1730  pRegPath->Buffer,
1731  pRegPath->Length);
1732  }
1733 
1735 
1736 Done:
1737  if (!NT_SUCCESS(status)) {
1738  This->Unlock(irql);
1739  }
1740 
1741  Irp->IoStatus.Status = status;
1742  Irp->IoStatus.Information = information;
1743 
1745 
1746  return status;
1747 }
ULONG RegistryPath
Definition: wmistr.h:95
CfxDevice * m_ParentDevice
Definition: fxdevice.hpp:569
GUID Guid
Definition: wmistr.h:79
#define IRP_MN_REGINFO_EX
#define TRUE
Definition: types.h:120
FxWmiProvider * pProvider
Definition: fxwmiapi.cpp:54
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
unsigned char * PUCHAR
Definition: retypes.h:3
ULONG Flags
Definition: wmistr.h:80
LONG NTSTATUS
Definition: precomp.h:26
KIRQL irql
Definition: wave.h:1
static stack_node_t * stack
Definition: rpn_ieee.c:37
ULONG GetRegistrationFlagsLocked(VOID)
ULONG MofResourceName
Definition: wmistr.h:96
PSINGLE_LIST_ENTRY ple
UCHAR KIRQL
Definition: env_spec_w32.h:591
ULONG GuidCount
Definition: wmistr.h:97
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
UNICODE_STRING m_MofResourceName
Definition: fxdevice.hpp:585
WMIREGGUIDW WmiRegGuid[]
Definition: wmistr.h:98
unsigned char BOOLEAN
PVOID pBuffer
#define IoCompleteRequest
Definition: irp.c:1240
WMIREGINFOW WMIREGINFO
Definition: wmistr.h:101
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
FxDevice * pDevice
PUNICODE_STRING GetRegistryPathUnicodeString(VOID)
Definition: fxdriver.hpp:243
Definition: _stack.h:47
MdDeviceObject __inline GetPhysicalDevice(VOID)
Definition: fxdevice.hpp:228
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
ULONG NextWmiRegInfo
Definition: wmistr.h:94
PWMIREGINFOW PWMIREGINFO
Definition: wmistr.h:102
__inline FxDriver * GetDriver(VOID)
Definition: fxdevice.hpp:164
size_t bufferSize
ULONG_PTR Pdo
Definition: wmistr.h:86
Definition: typedefs.h:119
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
ULONG BufferSize
Definition: wmistr.h:93
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
unsigned short USHORT
Definition: pedump.c:61
unsigned int * PULONG
Definition: retypes.h:1
#define NULL
Definition: types.h:112
ULONG InstanceCount
Definition: wmistr.h:81
#define ObReferenceObject
Definition: obfuncs.h:204
static PDB_INFORMATION information
Definition: db.cpp:178
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:598
#define ULONG_PTR
Definition: config.h:101
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define STATUS_SUCCESS
Definition: shellext.h:65
static SERVICE_STATUS status
Definition: service.c:31
unsigned short * PUSHORT
Definition: retypes.h:2
IN PVOID Instance
Definition: pci.h:361
#define WDF_PTR_ADD_OFFSET_TYPE(_ptr, _offset, _type)
Definition: wdfcore.h:141
Definition: ps.c:97

◆ 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.

427 {
431  KIRQL irql;
432  BOOLEAN providerAllocated, providerAdded, update;
433 
434  providerAllocated = FALSE;
435  providerAdded = FALSE;
436  update = FALSE;
437 
438  pInstance = NULL;
439 
441 
442  Lock(&irql);
443 
444  pProvider = FindProviderLocked(&ProviderConfig->Guid);
445 
446  if (pProvider == NULL) {
448  FxWmiProvider(GetDriverGlobals(), ProviderConfig, GetDevice());
449 
450  if (pProvider == NULL) {
452  goto Done;
453  }
454 
455  providerAllocated = TRUE;
456 
458  if (!NT_SUCCESS(status)) {
459  goto Done;
460  }
461 
462  providerAdded = TRUE;
463 
465  if (!NT_SUCCESS(status)) {
466  goto Done;
467  }
468  }
469  else if (pProvider->m_NumInstances > 0 &&
470  (FxIsEqualGuid(pProvider->GetGUID(), &GUID_POWER_DEVICE_ENABLE) ||
471  FxIsEqualGuid(pProvider->GetGUID(), &GUID_POWER_DEVICE_WAKE_ENABLE))) {
472 
474  "WMI Guid already registered by client driver");
476  }
477 
478  if (NT_SUCCESS(status)) {
480  FxWmiInstanceInternal(GetDriverGlobals(), InstanceCallbacks, pProvider);
481 
482  if (pInstance != NULL) {
484  }
485  else {
487  }
488 
489  if (NT_SUCCESS(status) &&
491  pInstance,
492  NULL) != NULL) {
493  //
494  // Some other thread got here first and created an instance, just
495  // bail out. the caller will handle this specific return value
496  // gracefully.
497  //
499  }
500  else {
501  //
502  // We are the first one to set the value, good for us.
503  //
504  DO_NOTHING();
505  }
506  }
507 
508  //
509  // Add the instance only if we are successful to this point
510  //
511  if (NT_SUCCESS(status)) {
512  //
513  // Passing FALSE indicates that this instance cannot be in the list
514  // when added.
515  //
517  pInstance,
518  FALSE,
519  &update,
521  );
522  }
523 
524 Done:
525  if (NT_SUCCESS(status)) {
526  if (update) {
527  update = DeferUpdateLocked(irql);
528  }
529  }
530  else if (providerAdded) {
532  }
533 
534  Unlock(irql);
535 
536  if (NT_SUCCESS(status)) {
537  if (update) {
538  UpdateGuids();
539  }
540  }
541  else {
542  if (pInstance != NULL) {
544  }
545 
546  if (providerAllocated) {
548  }
549  }
550 
551  return status;
552 }
#define STATUS_OBJECT_NAME_COLLISION
Definition: udferr_usr.h:150
__drv_restoresIRQL KIRQL __in BOOLEAN Unlock
Definition: fxobject.hpp:1474
virtual VOID DeleteObject(VOID)
__inline CfxDevice * GetDevice(VOID)
Definition: fxpackage.hpp:46
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_Must_inspect_result_ FxWmiProvider * FindProviderLocked(__in LPGUID Guid)
#define TRUE
Definition: types.h:120
FxWmiProvider * pProvider
Definition: fxwmiapi.cpp:54
_Must_inspect_result_ NTSTATUS AddProviderLocked(__in FxWmiProvider *Provider, __in KIRQL Irql, __out_opt PBOOLEAN Update=NULL)
LONG NTSTATUS
Definition: precomp.h:26
_Must_inspect_result_ BOOLEAN __inline FxIsEqualGuid(__in CONST GUID *Lhs, __in CONST GUID *Rhs)
Definition: fxglobals.h:977
KIRQL irql
Definition: wave.h:1
UCHAR KIRQL
Definition: env_spec_w32.h:591
GUID * GetGUID(VOID)
#define FALSE
Definition: types.h:117
#define InterlockedCompareExchangePointer
Definition: interlocked.h:129
VOID RemoveProviderLocked(__in FxWmiProvider *Provider)
_Must_inspect_result_ NTSTATUS AddInstanceLocked(__in FxWmiInstance *Instance, __in BOOLEAN NoErrorIfPresent, __out PBOOLEAN Update, __in AddInstanceAction Action=AddInstanceToTail)
unsigned char BOOLEAN
#define STATUS_WMI_GUID_DISCONNECTED
Definition: ntstatus.h:877
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
VOID UpdateGuids(VOID)
_Must_inspect_result_ NTSTATUS AssignParentObject(__in FxObject *ParentObject)
Definition: fxobject.cpp:529
#define TRACE_LEVEL_ERROR
Definition: storswtr.h:27
FxWmiInstanceExternal * pInstance
Definition: fxwmiapi.cpp:113
BOOLEAN DeferUpdateLocked(__in KIRQL OldIrql)
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
#define NULL
Definition: types.h:112
#define WDF_NO_OBJECT_ATTRIBUTES
Definition: wdftypes.h:105
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124
#define STATUS_SUCCESS
Definition: shellext.h:65
#define TRACINGIO
Definition: dbgtrace.h:66
static SERVICE_STATUS status
Definition: service.c:31
IN PVOID Instance
Definition: pci.h:361
#define DO_NOTHING()
Definition: mxgeneral.h:32
Definition: ps.c:97

◆ AddProvider()

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

Definition at line 398 of file fxwmiirphandler.cpp.

402 {
404  KIRQL irql;
405 
406  Lock(&irql);
407 
408  if (IsListEmpty(&Provider->m_ListEntry) == FALSE ||
409  FindProviderLocked(Provider->GetGUID()) != NULL) {
411  }
412  else {
414  }
415  Unlock(irql);
416 
417  return status;
418 }
__drv_restoresIRQL KIRQL __in BOOLEAN Unlock
Definition: fxobject.hpp:1474
_Must_inspect_result_ FxWmiProvider * FindProviderLocked(__in LPGUID Guid)
_Must_inspect_result_ NTSTATUS AddProviderLocked(__in FxWmiProvider *Provider, __in KIRQL Irql, __out_opt PBOOLEAN Update=NULL)
#define STATUS_OBJECT_NAME_EXISTS
Definition: ntstatus.h:114
LONG NTSTATUS
Definition: precomp.h:26
KIRQL irql
Definition: wave.h:1
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define FALSE
Definition: types.h:117
#define NULL
Definition: types.h:112
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

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.

265 {
266  BOOLEAN update;
267 
268  update = FALSE;
269 
270  switch (m_RegisteredState) {
271  case WmiRegistered:
272  if (Provider->m_Flags & WdfWmiProviderTracing) {
273  update = TRUE;
274  }
275  case WmiUnregistered:
276  break;
277 
278  case WmiDeregistered:
280  }
281 
282  //
283  // Didn't find it in the list, add it
284  //
285  m_NumProviders++;
287 
288  if (update) {
289  update = DeferUpdateLocked(OldIrql);
290 
291  if (Update != NULL) {
292  *Update = update;
293  }
294  }
295 
296  return STATUS_SUCCESS;
297 }
WmiRegisteredState m_RegisteredState
#define TRUE
Definition: types.h:120
#define InsertTailList(ListHead, Entry)
#define STATUS_INVALID_DEVICE_STATE
Definition: udferr_usr.h:178
#define FALSE
Definition: types.h:117
unsigned char BOOLEAN
__in __drv_restoresIRQL KIRQL OldIrql
Definition: fxobject.hpp:1465
LIST_ENTRY m_ProvidersListHead
BOOLEAN DeferUpdateLocked(__in KIRQL OldIrql)
#define NULL
Definition: types.h:112
#define STATUS_SUCCESS
Definition: shellext.h:65

Referenced by AddPowerPolicyProviderAndInstance(), and AddProvider().

◆ CheckAssumptions()

VOID FxWmiIrpHandler::CheckAssumptions ( VOID  )
staticprotected

Definition at line 75 of file fxwmiirphandler.cpp.

78 {
80  IRP_MN_REGINFO_EX + 1);
81 }
#define IRP_MN_REGINFO_EX
WDFCASSERT(sizeof(WDF_DRIVER_CONFIG_V1_0)==sizeof(WDF_DRIVER_CONFIG_V1_1))
static const FxWmiMinorEntry m_WmiDispatchTable[]

◆ Cleanup()

VOID FxWmiIrpHandler::Cleanup ( VOID  )

Definition at line 216 of file fxwmiirphandler.cpp.

219 {
220  KIRQL irql;
221 
222  Lock(&irql);
224  Unlock(irql);
225 }
__drv_restoresIRQL KIRQL __in BOOLEAN Unlock
Definition: fxobject.hpp:1474
WmiRegisteredState m_RegisteredState
KIRQL irql
Definition: wave.h:1
UCHAR KIRQL
Definition: env_spec_w32.h:591
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124

◆ CompleteWmiExecuteMethodRequest()

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

Definition at line 1838 of file fxwmiirphandler.cpp.

1843 {
1844  PWNODE_METHOD_ITEM pNodeMethod;
1845  ULONG bufferNeeded, information;
1846 
1847  pNodeMethod = (PWNODE_METHOD_ITEM)
1849 
1850  bufferNeeded = pNodeMethod->DataBlockOffset + BufferUsed;
1851 
1852  if (NT_SUCCESS(Status)) {
1853  pNodeMethod->WnodeHeader.BufferSize = bufferNeeded;
1854  pNodeMethod->SizeDataBlock = BufferUsed;
1855  KeQuerySystemTime(&pNodeMethod->WnodeHeader.TimeStamp);
1856 
1857  information = bufferNeeded;
1858  }
1859  else if (Status == STATUS_BUFFER_TOO_SMALL) {
1860  PWNODE_TOO_SMALL pNodeTooSmall;
1861 
1862  pNodeTooSmall = (PWNODE_TOO_SMALL) pNodeMethod;
1863 
1864  pNodeTooSmall->WnodeHeader.BufferSize = sizeof(WNODE_TOO_SMALL);
1865  pNodeTooSmall->WnodeHeader.Flags = WNODE_FLAG_TOO_SMALL;
1866  pNodeTooSmall->SizeNeeded = bufferNeeded;
1867 
1868  information = sizeof(WNODE_TOO_SMALL);
1870  }
1871  else {
1872  information = 0;
1873  }
1874 
1875  Irp->IoStatus.Information = information;
1876  Irp->IoStatus.Status = Status;
1877 }
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
_In_ ULONG _Out_ PULONG BufferUsed
Definition: wdfwmi.h:92
struct _WNODE_HEADER WnodeHeader
Definition: wmistr.h:52
struct tagWNODE_TOO_SMALL * PWNODE_TOO_SMALL
ULONG DataBlockOffset
Definition: wmistr.h:140
struct tagWNODE_METHOD_ITEM * PWNODE_METHOD_ITEM
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
struct tagWNODE_TOO_SMALL WNODE_TOO_SMALL
_In_ PIRP Irp
Definition: csq.h:116
Status
Definition: gdiplustypes.h:24
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
struct _WNODE_HEADER WnodeHeader
Definition: wmistr.h:136
static PDB_INFORMATION information
Definition: db.cpp:178
ULONG SizeNeeded
Definition: wmistr.h:53
unsigned int ULONG
Definition: retypes.h:1
#define STATUS_SUCCESS
Definition: shellext.h:65
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3128
#define WNODE_FLAG_TOO_SMALL
Definition: wmistr.h:33

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.

1755 {
1756  PWNODE_ALL_DATA pNodeAllData;
1757  ULONG bufferNeeded, information;
1759 
1761 
1762  pNodeAllData = (PWNODE_ALL_DATA) stack->Parameters.WMI.Buffer;
1763  bufferNeeded = pNodeAllData->DataBlockOffset + BufferUsed;
1764 
1765  if (NT_SUCCESS(Status) && bufferNeeded > stack->Parameters.WMI.BufferSize) {
1767  }
1768 
1769  if (NT_SUCCESS(Status)) {
1770  KeQuerySystemTime(&pNodeAllData->WnodeHeader.TimeStamp);
1771 
1772  pNodeAllData->WnodeHeader.BufferSize = bufferNeeded;
1773  information = bufferNeeded;
1774  }
1775  else if (Status == STATUS_BUFFER_TOO_SMALL) {
1776  PWNODE_TOO_SMALL pNodeTooSmall;
1777 
1778  pNodeTooSmall = (PWNODE_TOO_SMALL) stack->Parameters.WMI.Buffer;
1779 
1780  pNodeTooSmall->WnodeHeader.BufferSize = sizeof(WNODE_TOO_SMALL);
1781  pNodeTooSmall->WnodeHeader.Flags = WNODE_FLAG_TOO_SMALL;
1782  pNodeTooSmall->SizeNeeded = bufferNeeded;
1783 
1784  information = sizeof(WNODE_TOO_SMALL);
1786  }
1787  else {
1788  information = 0;
1789  }
1790 
1791  Irp->IoStatus.Information = information;
1792  Irp->IoStatus.Status = Status;
1793 }
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
_In_ ULONG _Out_ PULONG BufferUsed
Definition: wdfwmi.h:92
struct _WNODE_HEADER WnodeHeader
Definition: wmistr.h:52
struct tagWNODE_ALL_DATA * PWNODE_ALL_DATA
struct tagWNODE_TOO_SMALL * PWNODE_TOO_SMALL
static stack_node_t * stack
Definition: rpn_ieee.c:37
if(dx==0 &&dy==0)
Definition: linetemp.h:174
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
struct tagWNODE_TOO_SMALL WNODE_TOO_SMALL
_In_ PIRP Irp
Definition: csq.h:116
Definition: _stack.h:47
Status
Definition: gdiplustypes.h:24
ULONG DataBlockOffset
Definition: wmistr.h:113
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
static PDB_INFORMATION information
Definition: db.cpp:178
ULONG SizeNeeded
Definition: wmistr.h:53
unsigned int ULONG
Definition: retypes.h:1
struct _WNODE_HEADER WnodeHeader
Definition: wmistr.h:112
#define STATUS_SUCCESS
Definition: shellext.h:65
#define WNODE_FLAG_TOO_SMALL
Definition: wmistr.h:33

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.

1801 {
1802  PWNODE_SINGLE_INSTANCE pNodeSingle;
1803  ULONG bufferNeeded, information;
1804 
1805  pNodeSingle = (PWNODE_SINGLE_INSTANCE)
1807 
1808  bufferNeeded = pNodeSingle->DataBlockOffset + BufferUsed;
1809 
1810  if (NT_SUCCESS(Status)) {
1811  pNodeSingle->WnodeHeader.BufferSize = bufferNeeded;
1812  KeQuerySystemTime(&pNodeSingle->WnodeHeader.TimeStamp);
1813 
1814  ASSERT(pNodeSingle->SizeDataBlock <= BufferUsed);
1815  information = bufferNeeded;
1816  }
1817  else if (Status == STATUS_BUFFER_TOO_SMALL) {
1818  PWNODE_TOO_SMALL pNodeTooSmall;
1819 
1820  pNodeTooSmall = (PWNODE_TOO_SMALL) pNodeSingle;
1821 
1822  pNodeTooSmall->WnodeHeader.BufferSize = sizeof(WNODE_TOO_SMALL);
1823  pNodeTooSmall->WnodeHeader.Flags = WNODE_FLAG_TOO_SMALL;
1824  pNodeTooSmall->SizeNeeded = bufferNeeded;
1825 
1826  information = sizeof(WNODE_TOO_SMALL);
1828  }
1829  else {
1830  information = 0;
1831  }
1832 
1833  Irp->IoStatus.Information = information;
1834  Irp->IoStatus.Status = Status;
1835 }
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
_In_ ULONG _Out_ PULONG BufferUsed
Definition: wdfwmi.h:92
struct _WNODE_HEADER WnodeHeader
Definition: wmistr.h:52
struct tagWNODE_SINGLE_INSTANCE * PWNODE_SINGLE_INSTANCE
struct tagWNODE_TOO_SMALL * PWNODE_TOO_SMALL
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
struct tagWNODE_TOO_SMALL WNODE_TOO_SMALL
_In_ PIRP Irp
Definition: csq.h:116
Status
Definition: gdiplustypes.h:24
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
static PDB_INFORMATION information
Definition: db.cpp:178
ULONG SizeNeeded
Definition: wmistr.h:53
unsigned int ULONG
Definition: retypes.h:1
#define STATUS_SUCCESS
Definition: shellext.h:65
struct _WNODE_HEADER WnodeHeader
Definition: wmistr.h:58
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3128
#define WNODE_FLAG_TOO_SMALL
Definition: wmistr.h:33

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.

1911 {
1913  case IRP_MN_QUERY_ALL_DATA:
1915  break;
1916 
1919  break;
1920 
1921  case IRP_MN_EXECUTE_METHOD:
1923  break;
1924 
1927  //
1928  // Lot's of drivers return STATUS_BUFFER_TOO_SMALL for an invalid buffer
1929  // size. WMI expects STATUS_WMI_SET_FAILURE in this case. Change the
1930  // Status to the expected value. No way to return any size in
1931  // Information, the buffer is input only.
1932  //
1936  "Converting %!STATUS! to %!STATUS!",
1939  }
1940  // || || Fall through || ||
1941  // \/ \/ \/ \/
1942 
1943  default:
1944  //
1945  // All other requests don't return any data
1946  //
1947  Irp->IoStatus.Status = Status;
1948  Irp->IoStatus.Information = 0;
1949  break;
1950  }
1951 
1952  //
1953  // One of the complete functions may have morphed the status value
1954  //
1955  Status = Irp->IoStatus.Status;
1957 
1958  return Status;
1959 }
_In_ ULONG _Out_ PULONG BufferUsed
Definition: wdfwmi.h:92
#define IRP_MN_QUERY_SINGLE_INSTANCE
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
#define STATUS_WMI_SET_FAILURE
Definition: ntstatus.h:819
_In_ PIRP Irp
Definition: csq.h:116
#define TRACE_LEVEL_VERBOSE
Definition: storswtr.h:30
#define IRP_MN_CHANGE_SINGLE_ITEM
_In_ UCHAR _In_ UCHAR MinorFunction
Definition: wdfdevice.h:1697
#define IoCompleteRequest
Definition: irp.c:1240
Status
Definition: gdiplustypes.h:24
VOID CompleteWmiQuerySingleInstanceRequest(__in PIRP Irp, __in NTSTATUS Status, __in ULONG BufferUsed)
VOID CompleteWmiExecuteMethodRequest(__in PIRP Irp, __in NTSTATUS Status, __in ULONG BufferUsed)
#define IRP_MN_EXECUTE_METHOD
#define IRP_MN_CHANGE_SINGLE_INSTANCE
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
#define TRACINGPNP
Definition: dbgtrace.h:67
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
#define IRP_MN_QUERY_ALL_DATA
VOID CompleteWmiQueryAllDataRequest(__in PIRP Irp, __in NTSTATUS Status, __in ULONG BufferUsed)
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
#define IO_NO_INCREMENT
Definition: iotypes.h:598

◆ DecrementUpdateCount()

VOID FxWmiIrpHandler::DecrementUpdateCount ( )
inlineprivate

Definition at line 274 of file fxwmiirphandler.hpp.

274  {
275  LONG count;
276 
278  ASSERT(count >= 0);
279  if (count == 0) {
280  m_UpdateEvent.Set();
281  }
282  }
GLuint GLuint GLsizei count
Definition: gl.h:1545
VOID Set(VOID)
Definition: fxwaitlock.hpp:144
long LONG
Definition: pedump.c:60
#define ASSERT(a)
Definition: mode.c:44
#define InterlockedDecrement
Definition: armddk.h:52

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

◆ DecrementUpdateCountAndWait()

VOID FxWmiIrpHandler::DecrementUpdateCountAndWait ( )
inlineprivate

Definition at line 285 of file fxwmiirphandler.hpp.

285  {
286 
288 
290  }
NTSTATUS EnterCRAndWaitAndLeave(VOID)
Definition: fxwaitlock.hpp:87

Referenced by Deregister().

◆ DeferUpdateLocked()

BOOLEAN FxWmiIrpHandler::DeferUpdateLocked ( __in KIRQL  OldIrql)
private

Definition at line 300 of file fxwmiirphandler.cpp.

303 {
304  BOOLEAN checkQueue;
305 
306  checkQueue = FALSE;
307 
308  //
309  // Check to see if the caller is going to return to something > PASSIVE_LEVEL.
310  // If so, then always defer to the workitem.
311  //
312  if (OldIrql > PASSIVE_LEVEL) {
313  checkQueue = TRUE;
314  }
315  else {
316  //
317  // At passive level and updates are allowed, indicate to the caller to
318  // update. The caller will do registration update outside of lock but
319  // update count needs to be incremented under lock, so this is done here.
320  //
322  return TRUE;
323  }
324 
325  if (checkQueue && m_WorkItemQueued == FALSE) {
326  //
327  // we are going to queue a workitem which will do registration update,
328  // so increment the update count. Note that one work item may correspond
329  // to multiple requests to update (since if the workitem is already
330  // queued, it's not queued again).
331  //
333 
336  _UpdateGuids,
338  this);
339  }
340 
341  return FALSE;
342 }
static MX_WORKITEM_ROUTINE _UpdateGuids
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
unsigned char BOOLEAN
__in __drv_restoresIRQL KIRQL OldIrql
Definition: fxobject.hpp:1465
PIO_WORKITEM m_WorkItem
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
VOID NTAPI IoQueueWorkItem(IN PIO_WORKITEM IoWorkItem, IN PIO_WORKITEM_ROUTINE WorkerRoutine, IN WORK_QUEUE_TYPE QueueType, IN PVOID Context)
Definition: iowork.c:40

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

◆ Deregister()

VOID FxWmiIrpHandler::Deregister ( VOID  )

Definition at line 162 of file fxwmiirphandler.cpp.

165 {
167  KIRQL irql;
168  BOOLEAN call;
169 
170  call = FALSE;
171 
172  Lock(&irql);
175 
176  if (m_WorkItemQueued) {
177 
178 
179 
180 
181 
182  m_WorkItemEvent = (PKEVENT)event.GetEvent();
183  }
184 
185  call = TRUE;
186  }
187  Unlock(irql);
188 
189  if (m_WorkItemEvent != NULL) {
190  event.EnterCRAndWaitAndLeave();
191  }
192 
193  if (call) {
195 
196  //
197  // Per WMI rules, there should not be any call to update WMI
198  // registration after we have deregistered because that can lead to
199  // deadlock in Pnp, so before we go ahead to deregister, let's ensure
200  // that. This will wait for any pending updates to happen.
201  //
203 
206 
207  if (!NT_SUCCESS(status)) {
210  "failure deregistering WMI with OS, %!STATUS!", status);
211  }
212  }
213 }
__drv_restoresIRQL KIRQL __in BOOLEAN Unlock
Definition: fxobject.hpp:1474
PDEVICE_OBJECT GetDeviceObject(PPORTWAVECYCLIC iface)
__inline CfxDevice * GetDevice(VOID)
Definition: fxpackage.hpp:46
struct _KEVENT * PKEVENT
WmiRegisteredState m_RegisteredState
#define TRUE
Definition: types.h:120
#define WMIREG_ACTION_DEREGISTER
LONG NTSTATUS
Definition: precomp.h:26
KIRQL irql
Definition: wave.h:1
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define FALSE
Definition: types.h:117
unsigned char BOOLEAN
NTSTATUS NTAPI IoWMIRegistrationControl(IN PDEVICE_OBJECT DeviceObject, IN ULONG Action)
Definition: wmi.c:68
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
struct _cl_event * event
Definition: glext.h:7739
#define TRACE_LEVEL_ERROR
Definition: storswtr.h:27
#define TRACINGPNP
Definition: dbgtrace.h:67
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
#define NULL
Definition: types.h:112
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124
VOID DecrementUpdateCountAndWait()
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

◆ Dispatch()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::Dispatch ( __in PIRP  Irp)
virtual

Definition at line 632 of file fxwmiirphandler.cpp.

635 {
640  PDEVICE_OBJECT pAttached;
642  PVOID pTag;
643  ULONG instanceIndex;
644  KIRQL irql;
645  BOOLEAN handled, completeNow;
646  UCHAR minor;
647 
649 
651 
653  minor = stack->MinorFunction;
654  pTag = UlongToPtr(minor);
655  status = Irp->IoStatus.Status;
656 
657  pProvider = NULL;
658  pInstance = NULL;
659 
660  handled = FALSE;
661  completeNow = FALSE;
662 
665  "WDFDEVICE 0x%p !devobj 0x%p IRP_MJ_SYSTEM_CONTROL, %!sysctrl! IRP 0x%p",
667 
668  //
669  // Verify the minor code is within range, there is hole in the table at 0xA.
670  // This check works around the hole in the table.
671  //
673  goto Done;
674  }
675 
676  //
677  // If the irp is not targetted at this device, send it down the stack
678  //
679  if (stack->Parameters.WMI.ProviderId != (UINT_PTR) m_Device->GetDeviceObject()) {
680  goto Done;
681  }
682 
685  }
686  else {
687  Lock(&irql);
688 
689  pProvider = FindProviderLocked((LPGUID)stack->Parameters.WMI.DataPath);
690 
691  if (pProvider != NULL) {
693  }
694  else {
695  //
696  // check for WMI tracing (no pProvider)
697  //
699  }
700 
701  if (NT_SUCCESS(status) && m_WmiDispatchTable[minor].CheckInstance) {
702  PWNODE_SINGLE_INSTANCE pSingle;
703 
704  pSingle = (PWNODE_SINGLE_INSTANCE) stack->Parameters.WMI.Buffer;
705 
706  instanceIndex = pSingle->InstanceIndex;
707 
708  //
709  // Also possible bits set in Flags related to instance names
710  // WNODE_FLAG_PDO_INSTANCE_NAMES
711  //
712  if (pSingle->WnodeHeader.Flags & WNODE_FLAG_STATIC_INSTANCE_NAMES) {
713  //
714  // Try to get the instance
715  //
717  instanceIndex, pTag);
718 
719  if (pInstance == NULL) {
721  }
722  }
723  else {
724 
725 
726 
727 
728 
729 
731  }
732  }
733 
734  if (NT_SUCCESS(status)) {
735  pProvider->ADDREF(pTag);
736  }
737  else {
738  //
739  // NULL out the provider so we don't deref it later. We could not
740  // use if (pProvider != NULL && NT_SUCCESS(status) in the Done: block
741  // because we could have success here, but the dispatch function
742  // returns error.
743  //
744  pProvider = NULL;
745  }
746 
747  Unlock(irql);
748 
749  if (!NT_SUCCESS(status)) {
750  Irp->IoStatus.Status = status;
751  completeNow = TRUE;
752  }
753  }
754 
757  Irp,
758  pProvider,
759  pInstance);
760  handled = TRUE;
761  }
762 
763 Done:
764  if (pInstance != NULL) {
765  pInstance->RELEASE(pTag);
766  pInstance = NULL;
767  }
768 
769  if (pProvider != NULL) {
770  pProvider->RELEASE(pTag);
771  pProvider = NULL;
772  }
773 
774  if (handled == FALSE) {
775  pAttached = m_Device->GetAttachedDevice();
776  if (completeNow || pAttached == NULL) {
777  //
778  // Sent to a PDO, error in the FDO handling, or controller devobj
779  // style devobj, complete it here
780  //
781  status = Irp->IoStatus.Status;
783  }
784  else {
785  //
786  // Request sent to PNP device object that is not a PDO, send down
787  // the stack
788  //
790  status = IoCallDriver(pAttached, Irp);
791  }
792  }
793 
794  //
795  // Only release the remove lock *after* we have removed the thread entry
796  // from the list because the list lifetime is tied to the FxDevice lifetime
797  // and the remlock controls the lifetime of FxDevice.
798  //
799  // Since we never pend the wmi request, we can release the remove lock in
800  // this Dispatch routine. If we ever pended the IRPs, this would have to
801  // have some more logic involved.
802  //
805  Irp
806  );
807 
808  return status;
809 }
__drv_restoresIRQL KIRQL __in BOOLEAN Unlock
Definition: fxobject.hpp:1474
CfxDevice * m_Device
Definition: fxobject.hpp:329
#define IRP_MN_REGINFO
struct tagWNODE_SINGLE_INSTANCE * PWNODE_SINGLE_INSTANCE
#define STATUS_WMI_GUID_NOT_FOUND
Definition: ntstatus.h:776
MdDeviceObject __inline GetDeviceObject(VOID)
Definition: fxdevice.hpp:174
_Must_inspect_result_ FxWmiProvider * FindProviderLocked(__in LPGUID Guid)
#define IRP_MN_REGINFO_EX
#define TRUE
Definition: types.h:120
FxWmiProvider * pProvider
Definition: fxwmiapi.cpp:54
WDFDEVICE __inline GetHandle(VOID)
Definition: fxdevice.hpp:237
LONG NTSTATUS
Definition: precomp.h:26
#define IoReleaseRemoveLock(_RemoveLock, _Tag)
Definition: iofuncs.h:2764
__in PFN_WMI_HANDLER_MINOR_DISPATCH Handler
KIRQL irql
Definition: wave.h:1
static stack_node_t * stack
Definition: rpn_ieee.c:37
if(dx==0 &&dy==0)
Definition: linetemp.h:174
#define STATUS_WMI_INSTANCE_NOT_FOUND
Definition: ntstatus.h:777
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
#define TRACE_LEVEL_VERBOSE
Definition: storswtr.h:30
unsigned char BOOLEAN
MdDeviceObject __inline GetAttachedDevice(VOID)
Definition: fxdevice.hpp:210
#define IoCompleteRequest
Definition: irp.c:1240
#define UlongToPtr(u)
Definition: config.h:106
Definition: _stack.h:47
#define WNODE_FLAG_STATIC_INSTANCE_NAMES
Definition: wmistr.h:35
PFX_DRIVER_GLOBALS pFxDriverGlobals
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
_Must_inspect_result_ FxWmiInstance * GetInstanceReferencedLocked(__in ULONG Index, __in PVOID Tag)
unsigned char UCHAR
Definition: xmlstorage.h:181
#define IRP_MN_EXECUTE_METHOD
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER Handler
Definition: acpixf.h:668
static FxWdmDeviceExtension * _GetFxWdmExtension(__in MdDeviceObject DeviceObject)
Definition: fxdevicekm.hpp:30
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
FxWmiInstanceExternal * pInstance
Definition: fxwmiapi.cpp:113
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
static const FxWmiMinorEntry m_WmiDispatchTable[]
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421
FX_TRACK_DRIVER(fxDriverGlobals)
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:598
#define STATUS_SUCCESS
Definition: shellext.h:65
#define TRACINGIO
Definition: dbgtrace.h:66
struct _WNODE_HEADER WnodeHeader
Definition: wmistr.h:58
static SERVICE_STATUS status
Definition: service.c:31
ULONG minor
Definition: ps.c:97

◆ FindProviderLocked()

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

Definition at line 582 of file fxwmiirphandler.cpp.

585 {
586  FxWmiProvider* pFound;
588 
589  pFound = NULL;
590 
593  ple = ple->Flink) {
594 
596 
597  pProvider = CONTAINING_RECORD(ple, FxWmiProvider, m_ListEntry);
598 
600  Guid,
601  sizeof(GUID)) == sizeof(GUID)) {
602  pFound = pProvider;
603  break;
604  }
605  }
606 
607  return pFound;
608 }
FxWmiProvider * pProvider
Definition: fxwmiapi.cpp:54
PSINGLE_LIST_ENTRY ple
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
_Must_inspect_result_ _In_ WDFOBJECT _In_ CONST GUID * Guid
Definition: wdfobject.h:760
LIST_ENTRY m_ProvidersListHead
Definition: typedefs.h:119
#define NULL
Definition: types.h:112
#define RtlCompareMemory(s1, s2, l)
Definition: env_spec_w32.h:465

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.

616 {
618  KIRQL irql;
619 
620  Lock(&irql);
622  if (pProvider != NULL) {
623  pProvider->ADDREF(Tag);
624  }
625  Unlock(irql);
626 
627  return pProvider;
628 }
__drv_restoresIRQL KIRQL __in BOOLEAN Unlock
Definition: fxobject.hpp:1474
_Must_inspect_result_ FxWmiProvider * FindProviderLocked(__in LPGUID Guid)
FxWmiProvider * pProvider
Definition: fxwmiapi.cpp:54
KIRQL irql
Definition: wave.h:1
UCHAR KIRQL
Definition: env_spec_w32.h:591
_Must_inspect_result_ _In_ WDFOBJECT _In_ CONST GUID * Guid
Definition: wdfobject.h:760
_Must_inspect_result_ _In_ WDFDEVICE _In_ BOOLEAN _In_opt_ PVOID Tag
Definition: wdfdevice.h:4061
#define NULL
Definition: types.h:112
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124

◆ 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.

265  {
266  LONG count;
267 
269  ASSERT(count > 1);
271  }
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
GLuint GLuint GLsizei count
Definition: gl.h:1545
long LONG
Definition: pedump.c:60
#define ASSERT(a)
Definition: mode.c:44
#define InterlockedIncrement
Definition: armddk.h:53

Referenced by DeferUpdateLocked().

◆ PostCreateDeviceInitialize()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::PostCreateDeviceInitialize ( VOID  )

Definition at line 114 of file fxwmiirphandler.cpp.

117 {
119  if (m_WorkItem == NULL) {
121  }
122 
123  return STATUS_SUCCESS;
124 }
PDEVICE_OBJECT GetDeviceObject(PPORTWAVECYCLIC iface)
__inline CfxDevice * GetDevice(VOID)
Definition: fxpackage.hpp:46
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
PIO_WORKITEM NTAPI IoAllocateWorkItem(IN PDEVICE_OBJECT DeviceObject)
Definition: iowork.c:75
PIO_WORKITEM m_WorkItem
#define NULL
Definition: types.h:112
#define STATUS_SUCCESS
Definition: shellext.h:65

◆ Register()

_Must_inspect_result_ NTSTATUS FxWmiIrpHandler::Register ( VOID  )

Definition at line 128 of file fxwmiirphandler.cpp.

131 {
133  KIRQL irql;
134 
135  //
136  // We rely on the PnP state machine to manage our state transitions properly
137  // so that we don't have to do any state checking here.
138  //
139  Lock(&irql);
143  Unlock(irql);
144 
147 
148  if (!NT_SUCCESS(status)) {
151  "could not register WMI with OS, %!STATUS!", status);
152 
153  Lock(&irql);
155  Unlock(irql);
156  }
157 
158  return status;
159 }
__drv_restoresIRQL KIRQL __in BOOLEAN Unlock
Definition: fxobject.hpp:1474
PDEVICE_OBJECT GetDeviceObject(PPORTWAVECYCLIC iface)
__inline CfxDevice * GetDevice(VOID)
Definition: fxpackage.hpp:46
WmiRegisteredState m_RegisteredState
LONG NTSTATUS
Definition: precomp.h:26
KIRQL irql
Definition: wave.h:1
UCHAR KIRQL
Definition: env_spec_w32.h:591
NTSTATUS NTAPI IoWMIRegistrationControl(IN PDEVICE_OBJECT DeviceObject, IN ULONG Action)
Definition: wmi.c:68
#define WMIREG_ACTION_REGISTER
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define TRACE_LEVEL_ERROR
Definition: storswtr.h:27
#define TRACINGPNP
Definition: dbgtrace.h:67
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

◆ RemoveProvider()

VOID FxWmiIrpHandler::RemoveProvider ( __in FxWmiProvider Provider)
protected

Definition at line 555 of file fxwmiirphandler.cpp.

558 {
559  KIRQL irql;
560 
561  //
562  // No need to update via IoWMIRegistrationControl because this is only
563  // called in the error path of creating a provider.
564  //
565  Lock(&irql);
567  Unlock(irql);
568 }
__drv_restoresIRQL KIRQL __in BOOLEAN Unlock
Definition: fxobject.hpp:1474
KIRQL irql
Definition: wave.h:1
UCHAR KIRQL
Definition: env_spec_w32.h:591
VOID RemoveProviderLocked(__in FxWmiProvider *Provider)
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124

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

◆ RemoveProviderLocked()

VOID FxWmiIrpHandler::RemoveProviderLocked ( __in FxWmiProvider Provider)
protected

Definition at line 571 of file fxwmiirphandler.cpp.

574 {
575  m_NumProviders--;
576  RemoveEntryList(&Provider->m_ListEntry);
577  InitializeListHead(&Provider->m_ListEntry);
578 }
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944

Referenced by AddPowerPolicyProviderAndInstance(), and RemoveProvider().

◆ ResetStateForPdoRestart()

VOID FxWmiIrpHandler::ResetStateForPdoRestart ( VOID  )

Definition at line 228 of file fxwmiirphandler.cpp.

231 {
232  KIRQL irql;
233 
234  Lock(&irql);
235 
236  //
237  // We can reach this state in 2 ways:
238  // 1. PDO went through Init->Started->Removed->Started transition
239  // 2. PDO went through Init-><SomeFailedState>->Started state (e.g.
240  // Init->Ejected->EjectFailed->Started) transition.
241  //
242  // So, WMI registration state would either be Deregistered due to #1
243  // or, Unregistered due to #2. Also, update count would be 0 in case of #1
244  // and 1 in case of #2.
245  //
248  ASSERT(m_UpdateCount == 0 || m_UpdateCount == 1);
249 
250  //
251  // Update count is biased to 1 when created so do the same here.
252  //
253  m_UpdateCount = 1;
255  Unlock(irql);
256 }
__drv_restoresIRQL KIRQL __in BOOLEAN Unlock
Definition: fxobject.hpp:1474
CHECK_RETURN_IF_USER_MODE NTSTATUS Initialize(__in BOOLEAN InitialState=FALSE)
Definition: fxwaitlock.hpp:51
WmiRegisteredState m_RegisteredState
KIRQL irql
Definition: wave.h:1
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define ASSERT(a)
Definition: mode.c:44
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124

◆ UpdateGuids()

VOID FxWmiIrpHandler::UpdateGuids ( VOID  )
private

Definition at line 369 of file fxwmiirphandler.cpp.

372 {
374 
377 
378  if (!NT_SUCCESS(status)) {
381  "IoWMIRegistrationControl DevObj %p, for UpdateGuids failed, %!STATUS!",
383 
384  //
385  // Just drop the error
386  //
387  }
388 
389  //
390  // The caller incremented the update count when it decided to do the update.
391  // Decrement the count now that we have completed registration update.
392  //
394 }
PDEVICE_OBJECT GetDeviceObject(PPORTWAVECYCLIC iface)
__inline CfxDevice * GetDevice(VOID)
Definition: fxpackage.hpp:46
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI IoWMIRegistrationControl(IN PDEVICE_OBJECT DeviceObject, IN ULONG Action)
Definition: wmi.c:68
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define WMIREG_ACTION_UPDATE_GUIDS
#define TRACE_LEVEL_ERROR
Definition: storswtr.h:27
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
#define TRACINGIO
Definition: dbgtrace.h:66
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

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

◆ m_RegisteredState

◆ m_UpdateCount

LONG FxWmiIrpHandler::m_UpdateCount
protected

◆ m_UpdateEvent

FxCREvent FxWmiIrpHandler::m_UpdateEvent
protected

◆ 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

◆ 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: