ReactOS  0.4.15-dev-3303-g1ade494
FxEventQueue Struct Reference

#include <fxeventqueue.hpp>

Inheritance diagram for FxEventQueue:
Collaboration diagram for FxEventQueue:

Public Member Functions

 FxEventQueue (__in UCHAR QueueDepth)
 
_Must_inspect_result_ NTSTATUS Initialize (__in PFX_DRIVER_GLOBALS DriverGlobals)
 
 _Acquires_lock_ (this->m_QueueLock) __drv_maxIRQL(DISPATCH_LEVEL) __drv_setsIRQL(DISPATCH_LEVEL) VOID Lock(__out __drv_deref(__drv_savesIRQL) PKIRQL Irql)
 
 _Releases_lock_ (this->m_QueueLock) __drv_requiresIRQL(DISPATCH_LEVEL) VOID Unlock(__in __drv_restoresIRQL KIRQL Irql)
 
BOOLEAN IsFull (VOID)
 
BOOLEAN IsEmpty (VOID)
 
VOID IncrementHead (VOID)
 
UCHAR GetHead (VOID)
 
UCHAR InsertAtHead (VOID)
 
UCHAR InsertAtTail (VOID)
 
UCHAR IncrementHistoryIndex (VOID)
 
BOOLEAN IsClosedLocked (VOID)
 
VOID GetFinishedState (__inout FxPostProcessInfo *Info)
 
BOOLEAN SetFinished (__in FxCREvent *Event)
 
VOID SetDelayedDeletion (VOID)
 
- Public Member Functions inherited from FxStump
PVOID operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
 
PVOID operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in POOL_TYPE PoolType)
 
VOID operator delete (__in PVOID pointer)
 
PVOID operator new[] (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
 
VOID operator delete[] (__in PVOID pointer)
 

Public Attributes

FxWaitLockInternal m_StateMachineLock
 

Protected Member Functions

VOID Configure (__in FxPkgPnp *Pnp, __in PFN_PNP_EVENT_WORKER WorkerRoutine, __in PVOID Context)
 
BOOLEAN QueueToThreadWorker (VOID)
 
VOID EventQueueWorker (VOID)
 
BOOLEAN IsIdleLocked (VOID)
 
- Protected Member Functions inherited from FxStump
 FxStump (VOID)
 

Protected Attributes

UCHAR m_QueueHead
 
UCHAR m_QueueTail
 
UCHAR m_QueueDepth
 
UCHAR m_HistoryIndex
 
FxPkgPnpm_PkgPnp
 
PVOID m_EventWorkerContext
 
MxLock m_QueueLock
 
PFN_PNP_EVENT_WORKER m_EventWorker
 
FxCREventm_WorkItemFinished
 
union {
   UCHAR   m_QueueFlags
 
   struct {
      UCHAR   WorkItemQueued: 1
 
      UCHAR   Closed: 1
 
      UCHAR   DelayDeletion: 1
 
   }   m_QueueFlagsByName
 
}; 
 
UCHAR m_WorkItemRunningCount
 

Detailed Description

Definition at line 51 of file fxeventqueue.hpp.

Constructor & Destructor Documentation

◆ FxEventQueue()

FxEventQueue::FxEventQueue ( __in UCHAR  QueueDepth)

Definition at line 36 of file eventqueue.cpp.

39 {
40  m_PkgPnp = NULL;
42 
43  m_HistoryIndex = 0;
44  m_QueueHead = 0;
45  m_QueueTail = 0;
46  m_QueueDepth = QueueDepth;
47 
49  m_QueueFlags = 0x0;
51 }
FxCREvent * m_WorkItemFinished
FxPkgPnp * m_PkgPnp
PFN_PNP_EVENT_WORKER m_EventWorker
UCHAR m_WorkItemRunningCount
#define NULL
Definition: types.h:112
UCHAR m_HistoryIndex

Member Function Documentation

◆ _Acquires_lock_()

FxEventQueue::_Acquires_lock_ ( this->  m_QueueLock)
inline

Definition at line 62 of file fxeventqueue.hpp.

70  {
71  m_QueueLock.Acquire(Irql);
72  }
MxLock m_QueueLock
_Out_ PKIRQL Irql
Definition: csq.h:179

◆ _Releases_lock_()

FxEventQueue::_Releases_lock_ ( this->  m_QueueLock)
inline

Definition at line 74 of file fxeventqueue.hpp.

81  {
82  m_QueueLock.Release(Irql);
83  }
MxLock m_QueueLock
_Out_ PKIRQL Irql
Definition: csq.h:179

◆ Configure()

VOID FxEventQueue::Configure ( __in FxPkgPnp Pnp,
__in PFN_PNP_EVENT_WORKER  WorkerRoutine,
__in PVOID  Context 
)
protected

Definition at line 77 of file eventqueue.cpp.

82 {
83  m_PkgPnp = Pnp;
86 
87  return;
88 }
_Must_inspect_result_ _In_ PFLT_CALLBACK_DATA _In_ PFLT_DEFERRED_IO_WORKITEM_ROUTINE WorkerRoutine
Definition: fltkernel.h:1976
PVOID m_EventWorkerContext
FxPkgPnp * m_PkgPnp
PFN_PNP_EVENT_WORKER m_EventWorker
struct tagContext Context
Definition: acpixf.h:1034

Referenced by FxWorkItemEventQueue::Init(), and FxThreadedEventQueue::Init().

◆ EventQueueWorker()

VOID FxEventQueue::EventQueueWorker ( VOID  )
protected

Definition at line 229 of file eventqueue.cpp.

240 {
242  KIRQL irql;
243  FxPkgPnp* pPkgPnp;
244 
245 #if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
247 #endif
248 
249  //
250  // Cache away m_PkgPnp while we know we still have a valid object. Once
251  // we Unlock() after the worker routine, the object could be gone until
252  // the worker routine set a flag postponing deletion.
253  //
254  pPkgPnp = m_PkgPnp;
255 
256  Lock(&irql);
257 
259 
260  //
261  // Clear the queued flag, so that it's clear that the work item can
262  // be safely re-enqueued.
263  //
265 
266  //
267  // We should only see this count rise to a small number (like 10 or so).
268  //
271 
272  Unlock(irql);
273 
274  //
275  // Call the function that will actually run the state machine.
276  //
278 
279  Lock(&irql);
282  Unlock(irql);
283 
284  //
285  // NOTE: There is no need to use a reference count to keep this event queue
286  // (and the containing state machine) alive. Instead, the thread
287  // which wants to delete the state machine must wait for this work
288  // item to exit. If there was a reference to release, we would have
289  // a race between Unlock()ing and releasing the reference if the state
290  // machine moved into the finished state and deletes the device after
291  // we dropped the lock, but before we released the reference.
292  //
293  // This is important in that the device deletion can trigger
294  // DriverUnload to run before the release executes. DriverUnload
295  // frees the IFR buffer. If this potential release logs something to
296  // the IFR, you would bugcheck. Since it is impossible to defensively
297  // prevent all destructors from logging to the IFR, we can't use a
298  // ref count here to keep the queue alive.
299  //
300 
301  //
302  // If Evaluate needs to use pPkgPnp, then the call to the worker routine
303  // above made sure that pPkgPnp has not yet been freed.
304  //
305  info.Evaluate(pPkgPnp);
306 }
KIRQL irql
Definition: wave.h:1
UCHAR KIRQL
Definition: env_spec_w32.h:591
PVOID m_EventWorkerContext
FxPkgPnp * pPkgPnp
FxPkgPnp * m_PkgPnp
PFN_PNP_EVENT_WORKER m_EventWorker
#define ASSERT(a)
Definition: mode.c:44
UCHAR m_WorkItemRunningCount
struct _test_info info[]
Definition: SetCursorPos.c:19
VOID GetFinishedState(__inout FxPostProcessInfo *Info)
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
FX_TRACK_DRIVER(fxDriverGlobals)
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124

◆ GetFinishedState()

VOID FxEventQueue::GetFinishedState ( __inout FxPostProcessInfo Info)
inline

Definition at line 165 of file fxeventqueue.hpp.

168  {
169  if (IsIdleLocked()) {
172  Info->m_DeleteObject = TRUE;
173  }
174 
175  if (IsClosedLocked()) {
176  Info->m_Event = m_WorkItemFinished;
178  }
179  }
180  }
#define TRUE
Definition: types.h:120
FxCREvent * m_WorkItemFinished
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:683
BOOLEAN IsClosedLocked(VOID)
BOOLEAN IsIdleLocked(VOID)
#define NULL
Definition: types.h:112

Referenced by EventQueueWorker(), FxPkgPnp::PnpProcessEventInner(), FxPkgPnp::PowerPolicyProcessEventInner(), FxPkgPnp::PowerProcessEventInner(), FxDevicePwrRequirementMachine::ProcessEventInner(), and FxWakeInterruptMachine::ProcessEventInner().

◆ GetHead()

◆ IncrementHead()

◆ IncrementHistoryIndex()

◆ Initialize()

_Must_inspect_result_ NTSTATUS FxEventQueue::Initialize ( __in PFX_DRIVER_GLOBALS  DriverGlobals)

Definition at line 55 of file eventqueue.cpp.

58 {
60 
61  //
62  // For KM, lock initialize always succeeds. For UM, it might fail.
63  //
65  if (!NT_SUCCESS(status)) {
68  "Initializing state machine lock failed for EventQueue 0x%p, "
69  "status %!STATUS!",
70  this, status);
71  }
72 
73  return status;
74 }
CHECK_RETURN_IF_USER_MODE NTSTATUS Initialize()
Definition: fxwaitlock.hpp:235
LONG NTSTATUS
Definition: precomp.h:26
DriverGlobals
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define TRACE_LEVEL_ERROR
Definition: storswtr.h:27
#define TRACINGPNP
Definition: dbgtrace.h:67
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
static SERVICE_STATUS status
Definition: service.c:31
FxWaitLockInternal m_StateMachineLock
Definition: ps.c:97

Referenced by FxPkgFdo::_Create(), and FxInterrupt::CreateWakeInterruptMachine().

◆ InsertAtHead()

UCHAR FxEventQueue::InsertAtHead ( VOID  )
inline

◆ InsertAtTail()

UCHAR FxEventQueue::InsertAtTail ( VOID  )
inline

Definition at line 127 of file fxeventqueue.hpp.

130  {
131  UCHAR index;
132 
133  // Save the index which is the current tail
134  index = m_QueueTail;
135 
136  // goto next slot
138 
139  // return the old tail as the slot to insert at
140  return index;
141  }
GLuint index
Definition: glext.h:6031
unsigned char UCHAR
Definition: xmlstorage.h:181
#define index(s, c)
Definition: various.h:29

Referenced by FxPkgPnp::PnpProcessEvent(), FxPkgPnp::PowerPolicyProcessEvent(), FxPkgPnp::PowerProcessEvent(), FxDevicePwrRequirementMachine::ProcessEvent(), and FxWakeInterruptMachine::ProcessEvent().

◆ IsClosedLocked()

◆ IsEmpty()

◆ IsFull()

◆ IsIdleLocked()

BOOLEAN FxEventQueue::IsIdleLocked ( VOID  )
inlineprotected

Definition at line 211 of file fxeventqueue.hpp.

214  {
215  //
216  // We are idle if there is no work item queued, no work item running,
217  // and there are no events in the queue. Since m_WorkItemQueued is
218  // cleared before we enter the state machine, we must also track the
219  // number of work items running.
220  //
223  IsEmpty()) {
224  return TRUE;
225  }
226  else {
227  return FALSE;
228  }
229  }
GLint x0
Definition: linetemp.h:95
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
UCHAR m_WorkItemRunningCount
BOOLEAN IsEmpty(VOID)

Referenced by GetFinishedState(), and SetFinished().

◆ QueueToThreadWorker()

BOOLEAN FxEventQueue::QueueToThreadWorker ( VOID  )
protected

Definition at line 154 of file eventqueue.cpp.

179 {
180  KIRQL irql;
181  BOOLEAN result;
182 
183  Lock(&irql);
184 
185  //
186  // For one reason or another, we couldn't run the state machine on this
187  // thread. So queue a work item to do it.
188  //
189  if (IsEmpty()) {
190  //
191  // There is no work to do. This means that the caller inserted the
192  // event into the queue, dropped the lock, and then another thread came
193  // in and processed the event.
194  //
195  // This check also helps in the rundown case when the queue is closing
196  // and the following happens between 2 thread:
197  // #1 #2
198  // insert event
199  // drop lock
200  // process event queue
201  // queue goes to empty, so event is set
202  // try to queue work item
203  //
204  result = FALSE;
205 
208  "WDFDEVICE 0x%p !devobj 0x%p not queueing work item to process "
209  "event queue", m_PkgPnp->GetDevice()->GetHandle(),
211  }
212  else if ((m_QueueFlags & FxEventQueueFlagWorkItemQueued) == 0x00) {
214  result = TRUE;
215  }
216  else {
217  //
218  // Somebody is already in the process of enqueuing the work item.
219  //
220  result = FALSE;
221  }
222 
223  Unlock(irql);
224 
225  return result;
226 }
__inline CfxDevice * GetDevice(VOID)
Definition: fxpackage.hpp:46
MdDeviceObject __inline GetDeviceObject(VOID)
Definition: fxdevice.hpp:174
GLuint64EXT * result
Definition: glext.h:11304
#define TRUE
Definition: types.h:120
WDFDEVICE __inline GetHandle(VOID)
Definition: fxdevice.hpp:237
KIRQL irql
Definition: wave.h:1
#define TRACE_LEVEL_INFORMATION
Definition: storswtr.h:29
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define FALSE
Definition: types.h:117
unsigned char BOOLEAN
FxPkgPnp * m_PkgPnp
#define TRACINGPNP
Definition: dbgtrace.h:67
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
BOOLEAN IsEmpty(VOID)
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

Referenced by FxWorkItemEventQueue::QueueToThread(), and FxThreadedEventQueue::QueueToThread().

◆ SetDelayedDeletion()

VOID FxEventQueue::SetDelayedDeletion ( VOID  )

Definition at line 135 of file eventqueue.cpp.

138 {
139  KIRQL irql;
140 
143  "WDFDEVICE 0x%p !devobj 0x%p delaying deletion to outside state machine",
146 
147  Lock(&irql);
150  Unlock(irql);
151 }
__inline CfxDevice * GetDevice(VOID)
Definition: fxpackage.hpp:46
MdDeviceObject __inline GetDeviceObject(VOID)
Definition: fxdevice.hpp:174
GLint x0
Definition: linetemp.h:95
WDFDEVICE __inline GetHandle(VOID)
Definition: fxdevice.hpp:237
KIRQL irql
Definition: wave.h:1
#define TRACE_LEVEL_INFORMATION
Definition: storswtr.h:29
UCHAR KIRQL
Definition: env_spec_w32.h:591
FxPkgPnp * m_PkgPnp
#define ASSERT(a)
Definition: mode.c:44
#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

◆ SetFinished()

BOOLEAN FxEventQueue::SetFinished ( __in FxCREvent Event)

Definition at line 91 of file eventqueue.cpp.

109 {
110  KIRQL irql;
111  BOOLEAN result;
112 
113  result = TRUE;
114 
115  Lock(&irql);
118 
119  result = IsIdleLocked();
120 
121  if (result == FALSE) {
123  }
124 
125  Unlock(irql);
126 
127  if (result) {
128  Event->Set();
129  }
130 
131  return result;
132 }
GLint x0
Definition: linetemp.h:95
GLuint64EXT * result
Definition: glext.h:11304
#define TRUE
Definition: types.h:120
FxCREvent * m_WorkItemFinished
KIRQL irql
Definition: wave.h:1
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define FALSE
Definition: types.h:117
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
unsigned char BOOLEAN
#define ASSERT(a)
Definition: mode.c:44
BOOLEAN IsIdleLocked(VOID)
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124

Referenced by FxPkgPnp::CleanupStateMachines().

Member Data Documentation

◆ @4516

union { ... }

◆ Closed

UCHAR FxEventQueue::Closed

Definition at line 279 of file fxeventqueue.hpp.

◆ DelayDeletion

UCHAR FxEventQueue::DelayDeletion

Definition at line 280 of file fxeventqueue.hpp.

◆ m_EventWorker

PFN_PNP_EVENT_WORKER FxEventQueue::m_EventWorker
protected

Definition at line 260 of file fxeventqueue.hpp.

Referenced by Configure(), EventQueueWorker(), and FxEventQueue().

◆ m_EventWorkerContext

PVOID FxEventQueue::m_EventWorkerContext
protected

Definition at line 249 of file fxeventqueue.hpp.

Referenced by Configure(), and EventQueueWorker().

◆ m_HistoryIndex

UCHAR FxEventQueue::m_HistoryIndex
protected

Definition at line 241 of file fxeventqueue.hpp.

Referenced by FxEventQueue(), and IncrementHistoryIndex().

◆ m_PkgPnp

◆ m_QueueDepth

UCHAR FxEventQueue::m_QueueDepth
protected

◆ m_QueueFlags

◆ m_QueueFlagsByName

struct { ... } FxEventQueue::m_QueueFlagsByName

◆ m_QueueHead

UCHAR FxEventQueue::m_QueueHead
protected

Definition at line 233 of file fxeventqueue.hpp.

Referenced by FxEventQueue(), GetHead(), IncrementHead(), InsertAtHead(), IsEmpty(), and IsFull().

◆ m_QueueLock

MxLock FxEventQueue::m_QueueLock
protected

Definition at line 254 of file fxeventqueue.hpp.

Referenced by _Acquires_lock_(), and _Releases_lock_().

◆ m_QueueTail

UCHAR FxEventQueue::m_QueueTail
protected

Definition at line 236 of file fxeventqueue.hpp.

Referenced by FxEventQueue(), InsertAtTail(), IsEmpty(), and IsFull().

◆ m_StateMachineLock

◆ m_WorkItemFinished

FxCREvent* FxEventQueue::m_WorkItemFinished
protected

Definition at line 267 of file fxeventqueue.hpp.

Referenced by FxEventQueue(), GetFinishedState(), and SetFinished().

◆ m_WorkItemRunningCount

UCHAR FxEventQueue::m_WorkItemRunningCount
protected

Definition at line 289 of file fxeventqueue.hpp.

Referenced by EventQueueWorker(), FxEventQueue(), and IsIdleLocked().

◆ WorkItemQueued

UCHAR FxEventQueue::WorkItemQueued

Definition at line 278 of file fxeventqueue.hpp.


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