ReactOS 0.4.15-dev-8119-g4fb2fdb
fxrequestbase.hpp
Go to the documentation of this file.
1/*++
2
3Copyright (c) Microsoft Corporation
4
5Module Name:
6
7 FxRequestBase.hpp
8
9Abstract:
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
17Author:
18
19
20
21
22Environment:
23
24 Both kernel and user mode
25
26Revision History:
27
28--*/
29
30#ifndef _FXREQUESTBASE_H_
31#define _FXREQUESTBASE_H_
32
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//
72typedef
78 );
79
80
81struct 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
170
171public:
172
173 __inline
174 VOID
178 )
179 {
182 }
183
186 VOID
187 )
188 {
190
193
194 return pRoutine;
195 }
196
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
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
353 );
354
355 __inline
358 VOID
359 )
360 {
361 return m_Target;
362 }
363
364 VOID
365 __inline
368 )
369 {
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
391 }
392
393 __inline
394 ULONG
397 )
398 {
399 ULONG oldFlags;
400
401 oldFlags = m_TargetFlags;
402
403 // Assumes caller is holding appropriate lock
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
547 VOID
548 );
549
550 VOID
553 );
554
556 BOOLEAN
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 {
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 {
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
700 );
701
702 VOID
704 VOID
705 );
706
707protected:
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
763public:
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
798protected:
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_
unsigned char BOOLEAN
Type
Definition: Type.h:7
#define VOID
Definition: acefi.h:82
#define InterlockedDecrement
Definition: armddk.h:52
LONG NTSTATUS
Definition: precomp.h:26
Definition: fxirp.hpp:28
MdIrp GetIrp(VOID)
Definition: fxirpum.cpp:15
VOID SetContext(__in ULONG Index, __in PVOID Value)
Definition: fxirpum.cpp:351
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
__drv_restoresIRQL KIRQL __in BOOLEAN Unlock
Definition: fxobject.hpp:1474
VOID MarkDisposeOverride(__in FxObjectLockState State=ObjectLock)
Definition: fxobject.hpp:1101
MdIrp SetSubmitIrp(__in_opt MdIrp NewIrp, __in BOOLEAN FreeIrp=TRUE)
__inline BOOLEAN ShouldClearContext(VOID)
WDFOBJECT_OFFSET_ALIGNED m_OutputBufferOffset
SINGLE_LIST_ENTRY m_DrainSingleEntry
VOID __inline SetPriorityBoost(CCHAR PriorityBoost)
UCHAR CancelledFromTimer
LONG m_IrpCompletionReferenceCount
BOOLEAN m_CanComplete
__inline FxIrp * GetSubmitFxIrp(VOID)
BOOLEAN __inline IsCanComplete(VOID)
virtual ~FxRequestBase(VOID)
__inline VOID SetVerifierFlags(__in SHORT Flags)
DECLSPEC_NORETURN VOID FatalError(__in NTSTATUS Status)
VOID ClearFieldsForReuse(VOID)
__inline PVOID GetTraceObjectHandle(VOID)
WDFCONTEXT m_TargetCompletionContext
BOOLEAN Cancel(VOID)
FxRequestTimer * m_Timer
__inline VOID SetTargetFlags(__in UCHAR Flags)
__inline BOOLEAN HasContext(VOID)
FxIoTarget * m_Target
__inline BOOLEAN CanComplete(VOID)
FxIrpQueue * m_IrpQueue
VOID CompleteSubmitted(VOID)
__inline VOID ClearVerifierFlagsLocked(__in SHORT Flags)
struct FxRequestBase::@4807::@4815 m_TargetFlagsByName
static __inline FxRequestBase * _FromListEntry(__in PLIST_ENTRY Entry)
__inline BOOLEAN IsCompletionRoutineSet(VOID)
__inline ULONG ClearTargetFlags(__in UCHAR Flags)
__inline VOID SetContext(__in FxRequestContext *RequestContext=NULL)
UCHAR m_RequestBaseStaticFlags
LIST_ENTRY m_ListEntry
__inline VOID SetRequestBaseFlags(__in UCHAR Flags)
SHORT DriverInEvtIoStopContext
struct FxRequestBase::@4813::@4818 m_RequestBaseStaticFlagsByName
FxRequestContext * m_RequestContext
__inline VOID ClearVerifierFlags(__in SHORT Flags)
__inline BOOLEAN VerifierIsFormatted(VOID)
__inline VOID SetVerifierFlagsLocked(__in SHORT Flags)
__inline FxRequestContext * GetContext(VOID)
static __inline FxRequestBase * _FromDrainEntry(__in PSINGLE_LIST_ENTRY Entry)
UCHAR m_RequestBaseFlags
__inline MdIrp GetSubmitIrp(VOID)
__inline WDFREQUEST GetHandle(VOID)
SHORT GetVerifierFlagsLocked(VOID)
__inline VOID VerifierClearFormatted(VOID)
VOID ContextReleaseAndRestore(VOID)
__inline FxIoTarget * GetTarget(VOID)
VOID CompleteSubmittedNoContext(VOID)
struct FxRequestBase::@4809::@4816 m_VeriferFlagsByName
_Must_inspect_result_ BOOLEAN CancelTimer(VOID)
FxRequestCompletionCallback m_CompletionRoutine
_Must_inspect_result_ NTSTATUS ValidateTarget(__in FxIoTarget *Target)
BOOLEAN __inline IsAllocatedDriver(VOID)
__inline BOOLEAN IsCancelRoutineSet(VOID)
VOID ZeroOutDriverContext(VOID)
BOOLEAN m_NextStackLocationFormatted
struct FxRequestBase::@4811::@4817 m_RequestBaseFlagsByName
BOOLEAN __inline IsAllocatedFromIo(VOID)
__inline VOID VerifierSetFormatted(VOID)
__inline VOID SetCompletionRoutine(__in_opt PFN_WDF_REQUEST_COMPLETION_ROUTINE CompletionRoutine=NULL, __in_opt WDFCONTEXT CompletionContext=NULL)
VOID __inline SetTarget(__in FxIoTarget *Target)
virtual BOOLEAN Dispose(VOID)
SHORT DriverInprocessContext
FX_DECLARE_VF_FUNCTION(VOID, VerifyDispose)
__inline BOOLEAN HasContextType(__in FX_REQUEST_CONTEXT_TYPE Type)
static __inline FxRequestBase * _FromCsqContext(__in PMdIoCsqIrpContext Context)
MdIoCsqIrpContext m_CsqContext
__inline VOID SetCompleted(__in BOOLEAN Value)
__inline SHORT GetVerifierFlags(VOID)
WDFOBJECT_OFFSET_ALIGNED m_SystemBufferOffset
WDFCONTEXT ClearCompletionContext(VOID)
static MdDeferredRoutineType _TimerDPC
__inline VOID EnableContextDisposeNotification(VOID)
PFN_WDF_REQUEST_COMPLETION_ROUTINE ClearCompletionRoutine(VOID)
UCHAR SyncCleanupContext
VOID FreeMdls(VOID)
VOID StartTimer(__in LONGLONG Timeout)
__inline UCHAR GetTargetFlags(VOID)
FxRequestCancelCallback m_CancelRoutine
CCHAR __inline GetPriorityBoost(VOID)
PFN_WDF_REQUEST_CANCEL m_Cancel
PFN_WDF_REQUEST_COMPLETION_ROUTINE m_Completion
_In_ PIRP Irp
Definition: csq.h:116
#define __in
Definition: dbghelp.h:35
#define __in_opt
Definition: dbghelp.h:38
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
KIRQL irql
Definition: wave.h:1
UCHAR KIRQL
Definition: env_spec_w32.h:591
return pObject GetObjectHandle()
FxObjectType
Definition: fxobject.hpp:117
@ FxObjectTypeExternal
Definition: fxobject.hpp:120
return pRequest CreateTimer()
FxRequestAllocationSource
@ REQUEST_ALLOCATED_FROM_IO
@ REQUEST_ALLOCATED_DRIVER
@ REQUEST_ALLOCATED_INTERNAL
FxRequestConstructorCaller
@ FxRequestConstructorCallerIsDriver
@ FxRequestConstructorCallerIsFx
FxRequestTargetFlags
@ FX_REQUEST_PENDED
@ FX_REQUEST_TIMER_SET
@ FX_REQUEST_IGNORE_STATE
@ FX_REQUEST_COMPLETED
@ FX_REQUEST_CANCELLED_FROM_TIMER
FxRequestBaseStaticFlags
@ FxRequestBaseStaticSystemBufferValid
@ FxRequestBaseStaticOutputBufferValid
FxRequestBaseFlags
@ FxRequestBaseOutputMdlMapped
@ FxRequestBaseSyncCleanupContext
@ FxRequestBaseSystemMdlMapped
FxRequestVerifierFlags
@ FXREQUEST_FLAG_DRIVER_INPROCESS_CONTEXT
@ FXREQUEST_FLAG_TAG_REQUEST
@ FXREQUEST_FLAG_FORMATTED
@ FXREQUEST_FLAG_CANCELLED
@ FXREQUEST_FLAG_DRIVER_CANCELABLE
@ FXREQUEST_FLAG_DRIVER_IN_EVTIOSTOP_CONTEXT
@ FXREQUEST_FLAG_FORWARDED
@ FXREQUEST_FLAG_SENT_TO_TARGET
@ FXREQUEST_FLAG_DRIVER_DISPATCH
@ FXREQUEST_FLAG_RESERVED_REQUEST_ASSOCIATED_WITH_IRP
@ FXREQUEST_FLAG_DRIVER_OWNED
FxRequestCompletionState
@ FxRequestCompletionStateIoPkgFlag
@ FxRequestCompletionStateIoPkg
@ FxRequestCompletionStateQueue
@ FxRequestCompletionStateNone
VOID(* PFN_COMPLETE_COPY_ROUTINE)(__in FxIoTarget *This, __in FxRequest *Request, __in_opt FxRequestContext *Context)
FxRequestIrpOwnership
@ FxRequestDoesNotOwnIrp
@ FxRequestOwnsIrp
UCHAR FX_REQUEST_CONTEXT_TYPE
@ FX_REQUEST_CONTEXT_TYPE_NONE
Status
Definition: gdiplustypes.h:25
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLbitfield flags
Definition: glext.h:7161
#define ASSERT(a)
Definition: mode.c:44
ObjectType
Definition: metafile.c:81
#define _Must_inspect_result_
Definition: ms_sal.h:558
KDEFERRED_ROUTINE MdDeferredRoutineType
Definition: mxkm.h:35
IWudfIrp * MdIrp
Definition: mxum.h:103
#define DECLSPEC_NORETURN
Definition: ntbasedef.h:176
short SHORT
Definition: pedump.c:59
long LONG
Definition: pedump.c:60
unsigned short USHORT
Definition: pedump.c:61
static ULONG Timeout
Definition: ping.c:61
base of all file and directory entries
Definition: entries.h:83
FX_REQUEST_CONTEXT_TYPE m_RequestType
virtual VOID ReleaseAndRestore(__in FxRequestBase *Request)
Definition: typedefs.h:120
Definition: ntbasedef.h:628
int64_t LONGLONG
Definition: typedefs.h:68
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
char CCHAR
Definition: typedefs.h:51
_In_ WDFREQUEST Request
Definition: wdfdevice.h:547
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
_In_ WDFREQUEST _In_ NTSTATUS _In_ CCHAR PriorityBoost
Definition: wdfrequest.h:1016
_In_ WDFIOTARGET Target
Definition: wdfrequest.h:306
EVT_WDF_REQUEST_COMPLETION_ROUTINE * PFN_WDF_REQUEST_COMPLETION_ROUTINE
Definition: wdfrequest.h:313
_In_ WDFREQUEST _In_opt_ PFN_WDF_REQUEST_COMPLETION_ROUTINE _In_opt_ __drv_aliasesMem WDFCONTEXT CompletionContext
Definition: wdfrequest.h:898
_In_ WDFREQUEST _In_opt_ PFN_WDF_REQUEST_COMPLETION_ROUTINE CompletionRoutine
Definition: wdfrequest.h:895
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:127
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
unsigned char UCHAR
Definition: xmlstorage.h:181
unsigned char BYTE
Definition: xxhash.c:193