ReactOS  0.4.15-dev-3173-g40ee59d
fxrequestbase.hpp
Go to the documentation of this file.
1 /*++
2 
3 Copyright (c) Microsoft Corporation
4 
5 Module Name:
6 
7  FxRequestBase.hpp
8 
9 Abstract:
10 
11  This is the base class which request objects derive from for the driver
12  frameworks.
13 
14  The request base object wraps the IRP, containing persistent
15  information required by the driver frameworks.
16 
17 Author:
18 
19 
20 
21 
22 Environment:
23 
24  Both kernel and user mode
25 
26 Revision History:
27 
28 --*/
29 
30 #ifndef _FXREQUESTBASE_H_
31 #define _FXREQUESTBASE_H_
32 
33 #include "fxrequestcallbacks.hpp"
34 
35 #define WDF_REQUEST_REUSE_MUST_COMPLETE 2
36 
37 
38 //
39 // COMPLETED - set when the request's i/o completion routine has executed
40 //
41 // PENDED - set when the request has been put onto the target's CSQ
42 //
43 // TIMER_SET - set when a timer has been queued along with sending the request
44 // down to the target
45 //
46 // CANCELLED_FROM_TIME - set by the timer to indicate that the request was
47 // cancelled by the timer DPC
48 //
49 // IGNORE_STATE - set when the request is going to be sent ignoring the
50 // state of the target.
51 //
58 };
59 
60 //
61 // internal private constraints
62 //
63 #define WDF_REQUEST_SEND_INTERNAL_OPTION_FAIL_ON_PEND (0x80000000)
64 
65 #define WDF_REQUEST_INTERNAL_CONSTRAINTS_VALID_FLAGS \
66  (WDF_REQUEST_SEND_INTERNAL_OPTION_FAIL_ON_PEND)
67 
68 
69 //
70 // Completion event callback prototype
71 //
72 typedef
73 VOID
78  );
79 
80 
81 struct FxRequestTimer : public FxStump {
83 };
84 
86  REQUEST_ALLOCATED_FROM_IO = 0, // Irp came from the I/O package
87  REQUEST_ALLOCATED_INTERNAL = 1, // Irp was allocated internally and should be freed by the request
88  REQUEST_ALLOCATED_DRIVER = 2, // Irp was given to the request by the driver writer
89 };
90 
94 };
95 
96 // begin_wpp config
97 // CUSTOM_TYPE(FxRequestIrpOwnership, ItemEnum(FxRequestIrpOwnership));
98 // end_wpp
99 
103 };
104 
105 //
106 // These defines are for VerifierFlags
107 //
109  // Request has been passed to the Driver
111 
112  // Request was returned as a "Tag" request to WdfIoQueuePeekNextRequest.
114 
115  // Request has been forwarded from one queue to another
117 
118  // Request is being EvtIoDefault to the driver
120 
121  // The driver has specified the request as cancelable
123 
125 
126  // The request has been cancelled
128 
129  // the next stack location has been formatted
131 
132  // the request has been sent on an I/O target and is in the target's sent list
134 
135  // used to make sure the driver stop acknowledges in the context of EvtIoStop
137 
138  // used to indicate whether the Reserved Request is in use or on Free list
140 };
141 
146 };
147 
151 };
152 
153 //
154 // Designed to fit into a byte. FxRequestCompletionPkgFlag is a bit value
155 // used to distinguish between calling back into the io package or the current
156 // queue. When calling back into the current queue, we assume m_IoQueue is valid
157 //
160 
164 };
165 
167 
168  friend FxIoTarget;
170 
171 public:
172 
173  __inline
174  VOID
178  )
179  {
182  }
183 
186  VOID
187  )
188  {
190 
193 
194  return pRoutine;
195  }
196 
197  WDFCONTEXT
199  VOID
200  )
201  {
202  WDFCONTEXT pContext;
203 
204  pContext = m_TargetCompletionContext;
206 
207  return pContext;
208  }
209 
210  __inline
211  BOOLEAN
213  VOID
214  )
215  {
217  TRUE : FALSE;
218  }
219 
220  __inline
221  BOOLEAN
223  VOID
224  )
225  {
226  return (m_CancelRoutine.m_Cancel != NULL) ?
227  TRUE : FALSE;
228  }
229 
230  __inline
233  VOID
234  )
235  {
236  return m_RequestContext;
237  }
238 
239  __inline
240  VOID
242  __in FxRequestContext* RequestContext = NULL
243  )
244  {
245  //
246  // If we are setting to the same value, just return
247  //
248  if (m_RequestContext == RequestContext) {
249  return;
250  }
251 
252  //
253  // If we are changing the context to another unique pointer, free the
254  // old context.
255  //
256  if (m_RequestContext != NULL) {
257  delete m_RequestContext;
258  }
259 
260  m_RequestContext = RequestContext;
261  }
262 
263  VOID
265  VOID
266  )
267  {
268  //
269  // This does not free the context, rather it tells the context to release
270  // any references it is holding and restore fields back into the PIRP
271  //
272  if (m_RequestContext != NULL && m_Irp.GetIrp() != NULL) {
275  }
276  }
277 
278  __inline
279  VOID
281  VOID
282  )
283  {
285  }
286 
287  __inline
288  BOOLEAN
291  )
292  {
293  return (m_RequestContext != NULL &&
295  }
296 
297  __inline
298  BOOLEAN
300  VOID
301  )
302  {
303  return (m_RequestContext != NULL &&
306  }
307 
308  __inline
309  MdIrp
311  VOID
312  )
313  {
314  return m_Irp.GetIrp();
315  }
316 
317  __inline
318  FxIrp*
320  VOID
321  )
322  {
323  return &m_Irp;
324  }
325 
326  MdIrp
327  SetSubmitIrp(
328  __in_opt MdIrp NewIrp,
329  __in BOOLEAN FreeIrp = TRUE
330  );
331 
332  __inline
333  BOOLEAN
335  VOID
336  )
337  {
338  LONG count;
340  ASSERT(count >= 0);
341  return count == 0 ? TRUE : FALSE;
342  }
343 
344  VOID
346  VOID
347  );
348 
350  NTSTATUS
353  );
354 
355  __inline
356  FxIoTarget*
358  VOID
359  )
360  {
361  return m_Target;
362  }
363 
364  VOID
365  __inline
368  )
369  {
370  m_Target = Target;
371  }
372 
373  __inline
374  UCHAR
376  VOID
377  )
378  {
379  // Assumes caller is holding appropriate lock
380  return m_TargetFlags;
381  }
382 
383  __inline
384  VOID
387  )
388  {
389  // Assumes caller is holding appropriate lock
390  m_TargetFlags |= Flags;
391  }
392 
393  __inline
394  ULONG
397  )
398  {
399  ULONG oldFlags;
400 
401  oldFlags = m_TargetFlags;
402 
403  // Assumes caller is holding appropriate lock
404  m_TargetFlags &= ~Flags;
405 
406  return oldFlags;
407  }
408 
409  __inline
410  VOID
413  )
414  {
415  // Assumes caller is holding appropriate lock
417  }
418 
419  SHORT
421  VOID
422  )
423  {
424  ASSERT(GetDriverGlobals()->FxVerifierOn);
425  return m_VerifierFlags;
426  }
427 
428  __inline
429  SHORT
431  VOID
432  )
433  {
434  SHORT flags;
435  KIRQL irql;
436 
437  Lock(&irql);
439  Unlock(irql);
440 
441  return flags;
442  }
443 
444  __inline
445  VOID
448  )
449  {
451  }
452 
453  __inline
454  VOID
457  )
458  {
459  KIRQL irql;
460 
461  ASSERT(GetDriverGlobals()->FxVerifierOn);
462 
463  Lock(&irql);
465  Unlock(irql);
466  }
467 
468  __inline
469  VOID
472  )
473  {
475  }
476 
477  __inline
478  VOID
481  )
482  {
483  KIRQL irql;
484 
485  ASSERT(GetDriverGlobals()->FxVerifierOn);
486 
487  Lock(&irql);
489  Unlock(irql);
490  }
491 
492  __inline
493  VOID
495  VOID
496  )
497  {
498  if (GetDriverGlobals()->FxVerifierOn &&
499  GetDriverGlobals()->FxVerifierIO) {
501  }
502  }
503 
504  __inline
505  VOID
507  VOID
508  )
509  {
510  if (GetDriverGlobals()->FxVerifierOn &&
511  GetDriverGlobals()->FxVerifierIO) {
513  }
514  }
515 
516  __inline
517  BOOLEAN
519  VOID
520  )
521  {
522  if (GetDriverGlobals()->FxVerifierOn &&
523  GetDriverGlobals()->FxVerifierIO) {
525  }
526  else {
527  //
528  // we are not tracking the state
529  //
530  return TRUE;
531  }
532  }
533 
534  __inline
535  BOOLEAN
537  VOID
538  )
539  {
541  : FALSE;
542  }
543 
545  NTSTATUS
546  CreateTimer(
547  VOID
548  );
549 
550  VOID
551  StartTimer(
553  );
554 
556  BOOLEAN
557  CancelTimer(
558  VOID
559  );
560 
561  BOOLEAN
562  Cancel(
563  VOID
564  );
565 
566  BOOLEAN
567  __inline
569  VOID
570  )
571  {
573  }
574 
575  BOOLEAN
576  __inline
578  VOID
579  )
580  {
582  }
583 
584  BOOLEAN
585  __inline
587  VOID
588  )
589  {
590  return m_CanComplete;
591  }
592 
593  __inline
594  VOID
597  )
598  {
599  m_Completed = Value;
600  }
601 
602  VOID
603  __inline
606  )
607  {
609  }
610 
611  CCHAR
612  __inline
614  VOID
615  )
616  {
617  return m_PriorityBoost;
618  }
619 
620 
621 
622 
623 
624 
625 
626 
627 
628 
629 
630 
631 
632 
633  __inline
634  WDFREQUEST
636  VOID
637  )
638  {
639  return (WDFREQUEST) GetObjectHandle();
640  }
641 
642  __inline
643  static
647  )
648  {
650  }
651 
652  __inline
653  static
657  )
658  {
660  }
661 
662 
663  __inline
664  static
668  )
669  {
671  }
672 
673  __inline
674  PVOID
676  VOID
677  )
678  {
679  PVOID handle;
680 
682 
683  if (handle != NULL) {
684  return handle;
685  }
686  else {
687  return (PVOID) this;
688  }
689  }
690 
691  VOID
692  FreeMdls(
693  VOID
694  );
695 
697  VOID
698  FatalError(
700  );
701 
702  VOID
704  VOID
705  );
706 
707 protected:
709  __in PFX_DRIVER_GLOBALS FxDriverGlobals,
710  __in USHORT ObjectSize,
712  __in FxRequestIrpOwnership Ownership,
715  );
716 
717  virtual
719  VOID
720  );
721 
722  // Do not specify argument names
724  VOID,
725  VerifyDispose
726  );
727 
728  // FxObject overrides
729  virtual
730  BOOLEAN
731  Dispose(
732  VOID
733  );
734 
735  static
737 
738  VOID
740  VOID
741  );
742 
743  VOID
745  VOID
746  )
747  {
748 #if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
749  RtlZeroMemory(GetSubmitFxIrp()->GetDriverContext(),
750  GetSubmitFxIrp()->GetDriverContextSize());
751 #else
752  //
753  // UMDF host doesn't expose any easier way to zero out the contexts so
754  // set context to NULL one by one.
755  //
760 #endif
761  }
762 
763 public:
764 
765  union {
766  //
767  // The cancel safe queues use this context to identify
768  // the request in a race free manner.
769  //
771 
772  //
773  // IoTargets uses this to track the request when it is sent to the target.
774  // Since the request cannot be on an CSQ and sent to a target at the
775  // same time, we can unionize this with the CSQ context.
776  //
778  };
779 
780  union {
781  //
782  // IoTargest uses this when it needs to create a list of requests to cancel
783  // when making a state transition
784  //
786 
787  //
788  // If TRUE, the driver formatted the request by copying the current stack
789  // location to next or by manually passing in an IO_STACK_LOCATION. This
790  // is union'ed with m_DrainSingleEntry b/c it is only relevant during
791  // send and forget and the request is never enqueued on the target in
792  // this case and m_DrainSingleEntry is used when tracking requests sent
793  // on a target for cancelation due to a target state change.
794  //
796  };
797 
798 protected:
799  //
800  // The NT IRP is wrapped by a frameworks FxIrp
801  //
802  // Note: If m_Irp is NULL after initialization, this means
803  // the IRP was cancelled by a FxIrpQueue cancellation
804  // callback, or completed.
805  //
807 
808  //
809  // Target of the request. Access to this field is unguarded. The following
810  // have access to this field
811  // o The owning target itself
812  // o _TimerDPC()
813  // o Cancel() IFF it has successfully incremented the irp completion ref count
814  //
816 
818 
819 
820 
821 
823 
824  //
825  // Client driver completion routine to call when the request has come back
826  // from the target device.
827  //
829 
831 
832  //
833  // Context to pass to CompletionRoutine when called
834  //
836 
837  //
838  // Synchronization for this field is through Interlocked operations
839  //
841 
842  //
843  // Access to flags guarded by FxIoTarget::Lock
844  //
845  // Values defined in the enum FxRequestTargetFlags
846  //
847  union {
849 
850  //
851  // These are used purely for debugging, not in live code anywhere!
852  // NOTE: if FxRequestTargetFlagschanges, so this this union
853  //
854  struct {
861  };
862 
863  //
864  // Contains a value from the enum type FxRequestAllocationSource describing
865  // how the irp was allocated
866  //
868 
870 
872 
873  WDFOBJECT_OFFSET_ALIGNED m_SystemBufferOffset;
874 
875  union {
876  //
877  // These are flags used by verifier. Set with values from the enum
878  // FxRequestVerifierFlags
879  //
881 
882  struct {
894  };
895 
896  //
897  // If this is !=0, its an indication of outstanding references
898  // on WDM IRP fields such as any system buffers.
899  //
901 
902  // This field !=NULL if the request is on an IrpQueue.
904 
905  WDFOBJECT_OFFSET_ALIGNED m_OutputBufferOffset;
906 
907  union {
908  //
909  // Bit field. Set with values from the enum FxRequestBaseFlags
910  //
912 
913  struct {
918  };
919 
920  union {
921  //
922  // Bit field. Set with values from the enum FxRequestBaseStaticFlags
923  //
924 
925  //
927 
928  struct {
932  };
933 
934  //
935  // Priority boost.
936  //
938 
939  //
940  // Contains values from FxRequestCompletionState
941  //
943 
944  //
945  // TRUE, request can be completed by the driver.
946  //
948 
949  //
950  // If !=NULL, MDL allocated and assocated with the request
951  //
953 };
954 
955 #if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
956 #include "fxrequestbasekm.hpp"
957 #elif ((FX_CORE_MODE)==(FX_CORE_USER_MODE))
958 #include "fxrequestbaseum.hpp"
959 #endif
960 
961 
962 #endif // _FXREQUESTBASE_H_
__inline ULONG ClearTargetFlags(__in UCHAR Flags)
PFN_WDF_REQUEST_CANCEL m_Cancel
__inline VOID SetCompletionRoutine(__in_opt PFN_WDF_REQUEST_COMPLETION_ROUTINE CompletionRoutine=NULL, __in_opt WDFCONTEXT CompletionContext=NULL)
_Must_inspect_result_ NTSTATUS CreateTimer(VOID)
static __inline FxRequestBase * _FromDrainEntry(__in PSINGLE_LIST_ENTRY Entry)
__drv_restoresIRQL KIRQL __in BOOLEAN Unlock
Definition: fxobject.hpp:1474
FxRequestIrpOwnership
ObjectType
Definition: metafile.c:80
BOOLEAN Cancel(VOID)
UCHAR CancelledFromTimer
virtual BOOLEAN Dispose(VOID)
VOID ClearFieldsForReuse(VOID)
FxIoTarget * m_Target
FxRequestTargetFlags
_In_ WDFREQUEST _In_opt_ PFN_WDF_REQUEST_COMPLETION_ROUTINE _In_opt_ __drv_aliasesMem WDFCONTEXT CompletionContext
Definition: wdfrequest.h:893
Definition: ntbasedef.h:628
#define __in_opt
Definition: dbghelp.h:38
#define TRUE
Definition: types.h:120
SHORT DriverInEvtIoStopContext
VOID SetContext(__in ULONG Index, __in PVOID Value)
Definition: fxirpum.cpp:351
GLuint GLuint GLsizei count
Definition: gl.h:1545
LONG NTSTATUS
Definition: precomp.h:26
__inline VOID SetRequestBaseFlags(__in UCHAR Flags)
_Must_inspect_result_ BOOLEAN CancelTimer(VOID)
__inline FxIrp * GetSubmitFxIrp(VOID)
CCHAR __inline GetPriorityBoost(VOID)
Definition: fxirp.hpp:28
UCHAR m_RequestBaseStaticFlags
_In_ WDFREQUEST Request
Definition: wdfdevice.h:547
BOOLEAN __inline IsAllocatedFromIo(VOID)
KIRQL irql
Definition: wave.h:1
__inline VOID ClearVerifierFlags(__in SHORT Flags)
FxRequestTimer * m_Timer
#define DECLSPEC_NORETURN
Definition: ntbasedef.h:176
LIST_ENTRY m_ListEntry
FX_DECLARE_VF_FUNCTION(VOID, VerifyDispose)
__inline VOID SetVerifierFlags(__in SHORT Flags)
LONG m_IrpCompletionReferenceCount
UCHAR KIRQL
Definition: env_spec_w32.h:591
FxObjectType
Definition: fxobject.hpp:117
FxRequestCancelCallback m_CancelRoutine
__inline UCHAR GetTargetFlags(VOID)
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED LPLOOKUPSERVICE_COMPLETION_ROUTINE HANDLE * handle
Definition: sock.c:82
__inline SHORT GetVerifierFlags(VOID)
VOID StartTimer(__in LONGLONG Timeout)
#define FALSE
Definition: types.h:117
_In_ WDFREQUEST _In_ NTSTATUS _In_ CCHAR PriorityBoost
Definition: wdfrequest.h:1011
_In_ PIRP Irp
Definition: csq.h:116
__inline BOOLEAN IsCompletionRoutineSet(VOID)
long LONG
Definition: pedump.c:60
WDFOBJECT_OFFSET_ALIGNED m_OutputBufferOffset
__inline VOID ClearVerifierFlagsLocked(__in SHORT Flags)
UCHAR SyncCleanupContext
short SHORT
Definition: pedump.c:59
SHORT DriverInprocessContext
VOID CompleteSubmittedNoContext(VOID)
VOID MarkDisposeOverride(__in FxObjectLockState State=ObjectLock)
Definition: fxobject.hpp:1101
PVOID __inline GetObjectHandle(VOID)
Definition: fxobject.hpp:603
virtual VOID ReleaseAndRestore(__in FxRequestBase *Request)
unsigned char BOOLEAN
struct FxRequestBase::@4564::@4569 m_RequestBaseStaticFlagsByName
__inline PVOID GetTraceObjectHandle(VOID)
IWudfIrp * MdIrp
Definition: mxum.h:103
EVT_WDF_REQUEST_COMPLETION_ROUTINE * PFN_WDF_REQUEST_COMPLETION_ROUTINE
Definition: wdfrequest.h:313
__inline VOID EnableContextDisposeNotification(VOID)
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
VOID __inline SetPriorityBoost(CCHAR PriorityBoost)
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:406
Status
Definition: gdiplustypes.h:24
VOID FreeMdls(VOID)
VOID(* PFN_COMPLETE_COPY_ROUTINE)(__in FxIoTarget *This, __in FxRequest *Request, __in_opt FxRequestContext *Context)
int64_t LONGLONG
Definition: typedefs.h:68
WDFCONTEXT m_TargetCompletionContext
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
__inline MdIrp GetSubmitIrp(VOID)
__inline VOID VerifierSetFormatted(VOID)
#define ASSERT(a)
Definition: mode.c:44
__inline VOID VerifierClearFormatted(VOID)
char CCHAR
Definition: typedefs.h:51
MdIrp SetSubmitIrp(__in_opt MdIrp NewIrp, __in BOOLEAN FreeIrp=TRUE)
Type
Definition: Type.h:6
PFN_WDF_REQUEST_COMPLETION_ROUTINE ClearCompletionRoutine(VOID)
FxRequestAllocationSource
VOID CompleteSubmitted(VOID)
FxRequestCompletionState
__inline FxIoTarget * GetTarget(VOID)
__inline VOID SetVerifierFlagsLocked(__in SHORT Flags)
FX_REQUEST_CONTEXT_TYPE m_RequestType
FxIrpQueue * m_IrpQueue
GLbitfield flags
Definition: glext.h:7161
FxRequestConstructorCaller
unsigned char UCHAR
Definition: xmlstorage.h:181
#define InterlockedDecrement
Definition: armddk.h:52
virtual ~FxRequestBase(VOID)
#define VOID
Definition: acefi.h:82
static MdDeferredRoutineType _TimerDPC
WDFOBJECT_OFFSET_ALIGNED m_SystemBufferOffset
VOID ZeroOutDriverContext(VOID)
__inline VOID SetCompleted(__in BOOLEAN Value)
Definition: typedefs.h:119
FxRequestBaseStaticFlags
__inline BOOLEAN CanComplete(VOID)
#define _Must_inspect_result_
Definition: ms_sal.h:558
_Must_inspect_result_ NTSTATUS ValidateTarget(__in FxIoTarget *Target)
__inline BOOLEAN IsCancelRoutineSet(VOID)
unsigned char BYTE
Definition: xxhash.c:193
FxRequestBaseFlags
UCHAR m_RequestBaseFlags
static __inline FxRequestBase * _FromCsqContext(__in PMdIoCsqIrpContext Context)
KDEFERRED_ROUTINE MdDeferredRoutineType
Definition: mxkm.h:35
WDFCONTEXT ClearCompletionContext(VOID)
FxRequestBase(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in USHORT ObjectSize, __in_opt MdIrp Irp, __in FxRequestIrpOwnership Ownership, __in FxRequestConstructorCaller Caller, __in FxObjectType ObjectType=FxObjectTypeExternal)
FxRequestCompletionCallback m_CompletionRoutine
struct FxRequestBase::@4562::@4568 m_RequestBaseFlagsByName
SHORT GetVerifierFlagsLocked(VOID)
__inline BOOLEAN HasContext(VOID)
UCHAR FX_REQUEST_CONTEXT_TYPE
static ULONG Timeout
Definition: ping.c:61
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
MdIrp GetIrp(VOID)
Definition: fxirpum.cpp:15
__inline BOOLEAN VerifierIsFormatted(VOID)
SINGLE_LIST_ENTRY m_DrainSingleEntry
unsigned short USHORT
Definition: pedump.c:61
PFN_WDF_REQUEST_COMPLETION_ROUTINE m_Completion
_In_ WDFREQUEST _In_opt_ PFN_WDF_REQUEST_COMPLETION_ROUTINE CompletionRoutine
Definition: wdfrequest.h:893
__inline FxRequestContext * GetContext(VOID)
struct FxRequestBase::@4558::@4566 m_TargetFlagsByName
BOOLEAN __inline IsCanComplete(VOID)
#define NULL
Definition: types.h:112
__inline VOID SetTargetFlags(__in UCHAR Flags)
struct FxRequestBase::@4560::@4567 m_VeriferFlagsByName
_In_ WDFIOTARGET Target
Definition: wdfrequest.h:306
VOID ContextReleaseAndRestore(VOID)
DECLSPEC_NORETURN VOID FatalError(__in NTSTATUS Status)
FxRequestContext * m_RequestContext
struct tagContext Context
Definition: acpixf.h:1034
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124
VOID __inline SetTarget(__in FxIoTarget *Target)
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
static __inline FxRequestBase * _FromListEntry(__in PLIST_ENTRY Entry)
MdIoCsqIrpContext m_CsqContext
__inline VOID SetContext(__in FxRequestContext *RequestContext=NULL)
#define __in
Definition: dbghelp.h:35
FxRequestVerifierFlags
__inline BOOLEAN ShouldClearContext(VOID)
BOOLEAN m_NextStackLocationFormatted
base of all file and directory entries
Definition: entries.h:82
__inline WDFREQUEST GetHandle(VOID)
BOOLEAN m_CanComplete
BOOLEAN __inline IsAllocatedDriver(VOID)
__inline BOOLEAN HasContextType(__in FX_REQUEST_CONTEXT_TYPE Type)