Public Member Functions |
Static Public Member Functions |
Protected Member Functions |
Protected Attributes |
Private Member Functions |
Static Private Member Functions |
Private Attributes |
Friends |
List of all members
FxRequest Class Reference
#include <fxrequest.hpp>
Inheritance diagram for FxRequest:
Collaboration diagram for FxRequest:
Static Private Member Functions | |
| static VOID | CheckAssumptions (VOID) |
Private Attributes | |
| friend | FxIoTarget |
| friend | FxIoQueue |
| friend | FxRequestMemory |
| friend | FxRequestOutputBuffer |
| friend | FxRequestSystemBuffer |
Friends | |
| VOID | GetTriageInfo (VOID) |
Additional Inherited Members | |
 Public Attributes inherited from FxRequestBase | |
| union { | |
| MdIoCsqIrpContext m_CsqContext | |
| LIST_ENTRY m_ListEntry | |
| }; | |
| union { | |
| SINGLE_LIST_ENTRY m_DrainSingleEntry | |
| BOOLEAN m_NextStackLocationFormatted | |
| }; | |
| Static Protected Member Functions inherited from FxObject | |
| static PVOID | _GetBase (__in FxObject *Object) |
| Static Protected Attributes inherited from FxRequestBase | |
| static MdDeferredRoutineType | _TimerDPC |
Detailed Description
Definition at line 396 of file fxrequest.hpp.
Constructor & Destructor Documentation
◆ FxRequest()
|
protected |
Definition at line 33 of file fxrequest.cpp.
39 :
40 FxRequestBase(FxDriverGlobals,
41 ObjectSize,
42 Irp,
43 Ownership,
44 Caller)
45{
49
51
55
61}
Definition: fxrequestbase.hpp:166
WDFOBJECT_OFFSET_ALIGNED m_OutputBufferOffset
Definition: fxrequestbase.hpp:905
WDFOBJECT_OFFSET_ALIGNED m_SystemBufferOffset
Definition: fxrequestbase.hpp:873
Definition: fxrequest.hpp:396
@ FxRequestConstructorCallerIsDriver
Definition: fxrequestbase.hpp:102
Member Function Documentation
◆ _Create()
|
static |
Definition at line 161 of file fxrequest.cpp.
170{
171 WDFOBJECT hRequest;
174
176
180 }
181
183 FxRequest(FxDriverGlobals,
184 Irp,
185 Ownership,
186 Caller,
188
192 }
193
196 }
197
200 }
201 else {
204
206 //
207 // Clear the irp out of the request so that the destructor does
208 // not free it. Since we are returning failure, the caller does
209 // not expect the PIRP passed in to be freed.
210 //
212 }
213
215 }
216 }
217 else {
219 }
220
222 "Irp %p Ownership %!FxRequestIrpOwnership! FxRequest %p, status %!STATUS!",
224
226}
_Must_inspect_result_ NTSTATUS Commit(__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out_opt WDFOBJECT *ObjectHandle, __in_opt FxObject *Parent=NULL, __in BOOLEAN AssignDriverAsDefaultParent=TRUE)
Definition: fxobject.cpp:904
MdIrp SetSubmitIrp(__in_opt MdIrp NewIrp, __in BOOLEAN FreeIrp=TRUE)
Definition: fxrequestbase.cpp:382
_Must_inspect_result_ NTSTATUS ValidateTarget(__in FxIoTarget *Target)
Definition: fxrequestbase.cpp:299
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
_Must_inspect_result_ NTSTATUS FxValidateObjectAttributes(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PWDF_OBJECT_ATTRIBUTES Attributes, __in ULONG Flags=FX_VALIDATE_OPTION_NONE_SPECIFIED)
Definition: fxvalidatefunctions.cpp:45
Definition: nsiface.idl:2307
_In_ PWDFDEVICE_INIT _In_ PWDF_OBJECT_ATTRIBUTES RequestAttributes
Definition: wdfdevice.h:3431
Referenced by FxUsbPipeContinuousReader::Config().
◆ _CreateForPackage()
|
static |
Definition at line 75 of file fxrequest.cpp.
102{
105
107
108 //
109 // Allocate the new FxRequest object in the per driver tracking pool
110 //
112
114 DoTraceLevelMessage(
116 "Memory allocation failed %!STATUS!",
119 }
120
121 //
122 // For forward progress the IRP can be NULL.
123 //
126 }
127
128 //
129 // Improve I/O perf by not parenting it to device. However, if verifier is
130 // turned on, the request is parented to the device to help track reference
131 // leaks.
132 //
135 NULL,
136 NULL,
137 FALSE);
138 }
139 else {
141 NULL,
142 Device,
143 FALSE);
144 }
145
148 }
149 else {
150 DoTraceLevelMessage(
154 }
155
157}
Definition: fxrequest.hpp:1505
VOID AssignMemoryBuffers(__in WDF_DEVICE_IO_TYPE IoType)
Definition: fxrequest.hpp:1372
Referenced by FxIoQueue::AllocateReservedRequest(), FxPkgIo::DispatchStep2(), and FxPkgGeneral::OnCreate().
◆ _FromOwnerListEntry()
|
inlinestatic |
Definition at line 489 of file fxrequest.hpp.
493 {
501 default:
504 }
505 }
◆ AddIrpReference()
Definition at line 2470 of file fxrequest.cpp.
2492{
2495
2498
2500
2502
2504 }
2505
2507
2508 return;
2509}
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
Definition: fxglobals.h:165
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:127
Referenced by FxRequestSystemBuffer::AddRef(), FxRequestOutputBuffer::AddRef(), AddRefOverride(), FxDmaTransactionBase::ReferenceRequest(), FxRequestMemory::SetBuffer(), and FxRequestMemory::SetMdl().
◆ AddRefOverride()
|
virtual |
Definition at line 2675 of file fxrequest.cpp.
2681{
2685 AddIrpReference();
2686 return 2;
2687 }
2688 else {
2690 }
2691}
ULONG __inline AddRef(__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
Definition: fxobject.hpp:826
Definition: ncftp.h:79
◆ AssignMemoryBuffers()
|
inlineprivate |
Definition at line 1372 of file fxrequest.hpp.
1375{
1376
1380
1381
1382
1383
1384
1385
1386
1387
1388
1391 //
1392 // Set the buffer in the memory interface. For kernel mode,
1393 // GetOutputBuffer is same as GetSystemBuffer, but for user-mode,
1394 // host provides separate buffers, so that input buffer can only be
1395 // read, and output buffer can only be written to.
1396 //
1399 break;
1400
1402 //
1403 // InputBuffer is in SystemBuffer
1404 // OutputBuffer is in MdlAddress with read access
1405 //
1406 KMDF_ONLY_CODE_PATH_ASSERT();
1408 break;
1409
1411 //
1412 // InputBuffer is in SystemBuffer
1413 // OutputBuffer is in MdlAddress with write access
1414 //
1415 KMDF_ONLY_CODE_PATH_ASSERT();
1417 break;
1418
1420 //
1421 // Internal device controls are kernel mode to kernel mode, and deal
1422 // with direct unmapped pointers.
1423 //
1424 // In addition, a normal device control with
1425 // RequestorMode == KernelMode is also treated as kernel mode
1426 // to kernel mode since the I/O Manager will not generate requests
1427 // with this setting from a user mode request.
1428 //
1429 KMDF_ONLY_CODE_PATH_ASSERT();
1434 );
1436 }
1437 else {
1438 return;
1439 }
1440 break;
1441 }
1442 break;
1443
1449 break;
1450
1452 KMDF_ONLY_CODE_PATH_ASSERT();
1455 }
1456 else {
1457 return;
1458 }
1459 break;
1460
1461 default:
1462 return;
1463 }
1464 break;
1465
1466 default:
1467 return;
1468 }
1469
1472 }
1475 }
1476}
ULONG GetParameterIoctlCodeBufferMethod(VOID)
Definition: fxirpum.cpp:1490
PVOID GetParameterIoctlType3InputBuffer(VOID)
Definition: fxirpum.cpp:1542
UCHAR m_RequestBaseStaticFlags
Definition: fxrequestbase.hpp:926
@ FxRequestBaseStaticSystemBufferValid
Definition: fxrequestbase.hpp:149
@ FxRequestBaseStaticOutputBufferValid
Definition: fxrequestbase.hpp:150
__inline VOID SetBuffer(__in PVOID Buffer)
Definition: fxrequest.hpp:334
#define IRP_MJ_INTERNAL_DEVICE_CONTROL
Referenced by _CreateForPackage().
◆ CheckAssumptions()
Definition at line 34 of file fxrequestkm.cpp.
53{
56
57 UNREFERENCED_PARAMETER(pWdfRequestParameters);
58 UNREFERENCED_PARAMETER(pIoStackLocation);
59
60 //
61 // FxRequest::GetParameters relies on these being exactly the same size
62 //
65
66 //
67 // The address of the offset in the structure needs to be 8 bit aligned
68 // so that we can store flags in the bottom 3 bits
69 //
72
75}
Definition: Bus_PDO_EvalMethod.c:93
struct _IO_STACK_LOCATION::@3970::@3974 Read
struct _IO_STACK_LOCATION::@3970::@3975 Write
union _IO_STACK_LOCATION::@1575 Parameters
Definition: wdfrequest.h:136
union _WDF_REQUEST_PARAMETERS::@3873 Parameters
_Must_inspect_result_ _In_ WDFQUEUE _In_opt_ WDFREQUEST _In_opt_ WDFFILEOBJECT _Inout_opt_ PWDF_REQUEST_PARAMETERS Parameters
Definition: wdfio.h:869
◆ ClearFieldsForReuse()
Definition at line 1294 of file fxrequest.hpp.
1297 {
1300
1302
1304 }
__inline VOID ClearBufferMdl(VOID)
Definition: fxrequest.hpp:323
__inline VOID ClearBufferMdl(VOID)
Definition: fxrequest.hpp:177
Referenced by Reuse().
◆ ClearPowerStopState()
Definition at line 1214 of file fxrequest.hpp.
◆ Complete()
Definition at line 770 of file fxrequest.hpp.
773 {
775
776 //
777 // Complete the current request object. Can be called directly
778 // by the FxIoQueue to complete a request.
779 //
780 // When an FxRequest is completed, it is marked as completed,
781 // removed from any CSQ it may be a member of, and any registered
782 // callback functions are called. Then the NT IRP is completed,
783 // and the reference count on the object due to the callback routine
784 // is released if a callback routine was specified.
785 //
786 // Completing a request object can cause its reference
787 // count to go to zero, thus deleting it. So the caller
788 // must either reference it explicitly, or not touch it
789 // any more after calling complete.
790 //
791
792 DoTraceLevelMessage(
794 "Completing WDFREQUEST 0x%p for IRP 0x%p with "
795 "Information 0x%I64x, %!STATUS!",
797
800 }
801 else {
802 SetPriorityBoost(0);
803 }
804
806 }
Definition: fxdevice.hpp:487
__inline CHAR GetDefaultPriorityBoost(VOID)
Definition: fxdevice.hpp:1111
VOID __inline SetPriorityBoost(CCHAR PriorityBoost)
Definition: fxrequestbase.hpp:604
NTSTATUS CompleteInternal(__in NTSTATUS Status)
Definition: fxrequest.cpp:515
return pList GetDevice()
Referenced by CompleteWithInformation(), FxIoQueue::DispatchRequestToDriver(), and FxPkgGeneral::OnCreate().
◆ CompleteInternal()
Definition at line 515 of file fxrequest.cpp.
542{
547 CfxDevice* pRefedDevice;
548
551 //
552 // Store off the irp into a local variable
553 //
555
556 //
557 // Lock is no longer required, since it's only used
558 // by verifier for already completed requests. This is a
559 // serious driver error anyway
560 //
561
562
564
566 //
567 // No lock needed in non-verifier case since this is only
568 // used to detect double completions with verifier on
569 //
572 }
573
574
575
576
577
578
579#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
580
581
582
583
584
585
586
592 (flagsMasked != 0)) {
593
594 DoTraceLevelMessage(
596 "Driver that handled WDFREQUEST 0x%p is requesting data to "
597 " be written back to the UserBuffer by returing a non zero value "
598 " in the Irp 0x%p Information field even though the OutputBufferLength "
600
601 //
602 // We will assert only if the Information field is not zero to warn
603 // the developer that it's a bad thing to do. However, we do avoid
604 // corruption of UserBuffer on completion by clearing the flag
605 // erroneously set by the I/O manager.
606 //
609 }
610
611 //
612 // Clear the flag to prevent the I/O manager from coping the
613 // data back from the SystemBuffer to Irp->UserBuffer
614 //
616 }
617#endif
618
619 //
620 // If the status code is one of the framework facility codes,
621 // map it to a standard NTSTATUS
622 //
623
624
626 DoTraceLevelMessage(
629
634 break;
635
638 break;
639
642 break;
643
644 default:
645 DoTraceLevelMessage(
649 break;
650 }
651
654 }
655
658 }
659
660 //
661 // It is invalid to complete any requests on an IRPQUEUE
662 //
665
668
669 //
670 // Some I/O request cleanup. Do not do this for driver created requests.
671 //
673 //
674 // Set the completion state to none
675 //
677
679 //
680 // Don't set the Queue to NULL for reserved requests.
681 //
683 }
684 }
685
686 //
687 // IMPORTANT: the context must free its references before the request is
688 // completed. Any of these references could be on a memory interface that is
689 // an embedded interface in this object. If this reference
690 // is left outstanding when we check m_IrpReferenceCount below, we would
691 // bugcheck (and the driver writer would be unaware of why things are going
692 // wrong).
693 //
694 // Also, if the driver is freeing the referenced mmemory interface in its
695 // cleanup routine, we don't want an oustanding reference against it.
696 //
698 //
699 // m_RequestContext will be freed when the FxRequest's desctructor runs
700 //
702 }
703
704 //
705 // If the request is not presented to the driver then clear the
706 // cleanup & destroy callbacks before calling PerformEarlyDispose.
707 //
709 ClearEvtCallbacks();
710 }
711
713 //
714 // Fire the driver supplied Cleanup callback if set
715 //
716 // This will allow the driver to release any IRP specific resources such
717 // as MDLs before we complete the IRP back to the OS, and release the
718 // process/thread reference.
719 //
720 // This is also the callback used to tell the driver the WDM IRP is going
721 // away if it has used the WDM "escape" API's to either get the IRP, or
722 // any resources it references.
723 //
724
725 //
726 // If a cleanup callback has been registered, we call it
727 // just before completing the IRP to WDM, which can cause any
728 // associated buffers, MDLs, or memory interfaces to be invalidated.
729 //
731 VerifierBreakpoint_RequestEarlyDisposeDeferred(GetDriverGlobals());
732 }
733
734 //
735 // Now that the entire tree is disposed, we want to destroy all of the
736 // children. This will not put this object in the destroyed state. For
737 // m_IrpReferenceCount to go to zero, we need to destroy the child WDFMEMORYs
738 // that were created when we probed and locked the buffers.
739 //
740 DestroyChildren();
741 }
742 else {
743 //
744 // We don't call cleanup callback for Reserved Requests.
745 // The driver can perform any cleanp it wants before completing the Request
746 // or before reusing the Reserved Request in its Dispatch callback.
747
748
749
750
751
752
753 DO_NOTHING();
754 }
755
756 //
757 // If this is non-zero, indicates a reference count problem on any
758 // WDFMEMORY objects returned to the device driver from this WDFREQUEST.
759 //
761 //
762 // NOTE: you cannot call GetBuffer or GetMdl
763 DoTraceLevelMessage(
765 "WDFREQUEST 0x%p, PIRP 0x%p, Major Function 0x%x, completed with "
766 "outstanding references on WDFMEMORY 0x%p or 0x%p retrieved from "
767 "this request",
775 );
776
779 DoTraceLevelMessage(
781 "WDFMEMORY 0x%p, buffer %p, PMDL %p, length %I64d bytes",
784 }
785
788 DoTraceLevelMessage(
790 "IOCTL output WDFMEMORY 0x%p, buffer %p, PMDL %p, length %I64d bytes",
793 }
794
799 }
800
802
803 //
804 // Complete the NT IRP through the frameworks FxIrp
805 //
807
809
810 //
811 // For driver created requests we need to use two phase
812 // completion (pre and post) to detach the request from the queue before the
813 // IRP is completed, and then allow a new request to be dispatched.
814 // Note that the IRP is actually completed when the reference on this object
815 // goes to 1 (See FxRequest::Release() for more info).
816 //
818 //
819 // Do not touch the request after this call.
820 // Do not clear the request's IRP field before making this call.
821 //
823 }
824 else {
825 //
826 // We only clear the irp from this object after PerformEarlyDispose has been
827 // called. m_SystemBuffer and m_OutputBuffer use m_Irp to return their
828 // buffers and their WDFMEMORY handles should be valid in the cleanup routine
829 // for the WDFREQUEST. We also keep m_Irp valid until after the
830 // m_IrpReferenceCount check, so we can trace out the buffers in case of
831 // error.
832 //
834
836 //
837 // If this is the last handle to be closed on the device, then the call
838 // to CreateCompleted can cause the device to be deleted if the create
839 // has failed. We add a reference so that we make sure we have a device
840 // to free the request memory back to.
841 //
842 pRefedDevice = GetDevice();
843 pRefedDevice->ADDREF(&irp);
844
846 }
847 else {
848 pRefedDevice = NULL;
849 }
850
851 //
852 // WDM IRP is completed.
853 //
855
858 }
859 else {
861 }
862
864 pRefedDevice->RELEASE(&irp);
865 pRefedDevice = NULL;
866 }
867 }
868
870}
Definition: fxioqueue.hpp:232
Definition: fxirp.hpp:28
VOID CompleteRequest(__in_opt CCHAR PriorityBoost=IO_NO_INCREMENT)
Definition: fxirpum.cpp:24
ULONG GetParameterIoctlOutputBufferLength(VOID)
Definition: fxirpum.cpp:1504
__inline BOOLEAN IsCancelRoutineSet(VOID)
Definition: fxrequestbase.hpp:222
BOOLEAN __inline IsAllocatedFromIo(VOID)
Definition: fxrequestbase.hpp:568
CCHAR __inline GetPriorityBoost(VOID)
Definition: fxrequestbase.hpp:613
VOID PostProcessCompletionForReserved(__in FxRequestCompletionState State, __in FxIoQueue *Queue)
Definition: fxrequest.cpp:916
VOID PostProcessCompletion(__in FxRequestCompletionState State, __in FxIoQueue *Queue)
Definition: fxrequest.cpp:874
VOID PreProcessCompletionForDriverRequest(__in FxRequestCompletionState State, __in FxIoQueue *Queue)
Definition: fxrequest.cpp:955
Definition: _queue.h:67
return pObject GetObjectHandle()
FxVerifierDbgBreakPoint(pFxDriverGlobals)
virtual VOID ReleaseAndRestore(__in FxRequestBase *Request)
Definition: fxrequestcontext.cpp:86
virtual _Must_inspect_result_ PMDL GetMdl(VOID)
Definition: fxrequestoutputbuffer.cpp:110
virtual PVOID GetBuffer(VOID)
Definition: fxrequestoutputbuffer.cpp:36
virtual size_t GetBufferSize(VOID)
Definition: fxrequestoutputbuffer.cpp:84
virtual WDFMEMORY GetHandle(VOID)
Definition: fxrequestoutputbuffer.cpp:142
virtual size_t GetBufferSize(VOID)
Definition: fxrequestsystembuffer.cpp:37
virtual _Must_inspect_result_ PVOID GetBuffer(VOID)
Definition: fxrequestsystembufferkm.cpp:38
virtual WDFMEMORY GetHandle(VOID)
Definition: fxrequestsystembuffer.cpp:119
virtual _Must_inspect_result_ PMDL GetMdl(VOID)
Definition: fxrequestsystembuffer.cpp:75
#define IRP_INPUT_OPERATION
Referenced by Complete(), and CompleteWithPriority().
◆ CompleteInternalReserved()
|
private |
◆ CompleteWithInformation()
|
inline |
Definition at line 810 of file fxrequest.hpp.
814 {
815 //
816 // Complete the request object. If the status is success, get the
817 // priority boost for the owning device type, and complete the request.
818 //
821 }
Referenced by FxIoQueue::GetRequest(), and FxIoQueue::QueueRequest().
◆ CompleteWithPriority()
|
inline |
Definition at line 825 of file fxrequest.hpp.
829 {
830 //
831 // Complete the current request object. Can be called directly
832 // by the FxIoQueue to complete a request.
833 //
834 // When an FxRequest is completed, it is marked as completed,
835 // removed from any CSQ it may be a member of, and any registered
836 // callback functions are called. Then the NT IRP is completed,
837 // and the reference count on the object due to the callback routine
838 // is released if a callback routine was specified.
839 //
840 // Completing a request object can cause its reference
841 // count to go to zero, thus deleting it. So the caller
842 // must either reference it explicitly, or not touch it
843 // any more after calling complete.
844 //
845
846 DoTraceLevelMessage(
848 "Completing WDFREQUEST 0x%p for IRP 0x%p with "
849 "Information 0x%I64x, %!STATUS!",
851
854 }
◆ CopyCompletionParams()
|
inline |
Definition at line 534 of file fxrequest.hpp.
537 {
542 }
543 else {
544 DoTraceLevelMessage(
546 "WdfRequestGetCompletionParams will not return valid information if the"
547 " request is not formatted using WdfIoTargetFormatxxx DDIs"
548 );
549
551
553 }
554 }
WDF_REQUEST_COMPLETION_PARAMS m_CompletionParams
Definition: fxrequestcontext.hpp:142
Definition: wdfrequest.h:222
FORCEINLINE VOID WDF_REQUEST_COMPLETION_PARAMS_INIT(_Out_ PWDF_REQUEST_COMPLETION_PARAMS Params)
Definition: wdfrequest.h:288
◆ CopyCurrentIrpStackLocationToNext()
Definition at line 509 of file fxrequest.hpp.
◆ FreeRequest()
Definition at line 1022 of file fxrequest.cpp.
1033{
1034 //
1035 // Restore any fields if necessary
1036 //
1038 //
1039 // m_RequestContext will be freed when the FxRequest's destructor runs
1040 //
1042 }
1043
1044 //
1045 // If the request is not presented to the driver then clear the
1046 // cleanup & destroy callbacks before calling PerformEarlyDispose.
1047 //
1049 ClearEvtCallbacks();
1050 }
1051
1052 DeleteObject();
1053}
pKey DeleteObject()
Referenced by FxIoQueue::AllocateReservedRequest().
◆ FX_DECLARE_VF_FUNCTION() [1/13]
| FxRequest::FX_DECLARE_VF_FUNCTION | ( | NTSTATUS | , |
| VerifyProbeAndLock | |||
| ) |
◆ FX_DECLARE_VF_FUNCTION() [2/13]
| FxRequest::FX_DECLARE_VF_FUNCTION | ( | NTSTATUS | , |
| VerifyRequestCanBeCompleted | |||
| ) |
◆ FX_DECLARE_VF_FUNCTION() [3/13]
| FxRequest::FX_DECLARE_VF_FUNCTION | ( | NTSTATUS | , |
| VerifyRequestIsAllocatedFromIo | |||
| ) |
◆ FX_DECLARE_VF_FUNCTION() [4/13]
| FxRequest::FX_DECLARE_VF_FUNCTION | ( | NTSTATUS | , |
| VerifyRequestIsCancelable | |||
| ) |
◆ FX_DECLARE_VF_FUNCTION() [5/13]
| FxRequest::FX_DECLARE_VF_FUNCTION | ( | NTSTATUS | , |
| VerifyRequestIsCurrentStackValid | |||
| ) |
◆ FX_DECLARE_VF_FUNCTION() [6/13]
| FxRequest::FX_DECLARE_VF_FUNCTION | ( | NTSTATUS | , |
| VerifyRequestIsDriverOwned | |||
| ) |
◆ FX_DECLARE_VF_FUNCTION() [7/13]
| FxRequest::FX_DECLARE_VF_FUNCTION | ( | NTSTATUS | , |
| VerifyRequestIsInCallerContext | |||
| ) |
◆ FX_DECLARE_VF_FUNCTION() [8/13]
| FxRequest::FX_DECLARE_VF_FUNCTION | ( | NTSTATUS | , |
| VerifyRequestIsInEvtIoStopContext | |||
| ) |
◆ FX_DECLARE_VF_FUNCTION() [9/13]
| FxRequest::FX_DECLARE_VF_FUNCTION | ( | NTSTATUS | , |
| VerifyRequestIsNotCancelable | |||
| ) |
◆ FX_DECLARE_VF_FUNCTION() [10/13]
| FxRequest::FX_DECLARE_VF_FUNCTION | ( | NTSTATUS | , |
| VerifyRequestIsNotCompleted | |||
| ) |
◆ FX_DECLARE_VF_FUNCTION() [11/13]
| FxRequest::FX_DECLARE_VF_FUNCTION | ( | NTSTATUS | , |
| VerifyRequestIsTagRequest | |||
| ) |
◆ FX_DECLARE_VF_FUNCTION() [12/13]
| FxRequest::FX_DECLARE_VF_FUNCTION | ( | VOID | , |
| VerifierBreakpoint_RequestEarlyDisposeDeferred | |||
| ) |
◆ FX_DECLARE_VF_FUNCTION() [13/13]
| FxRequest::FX_DECLARE_VF_FUNCTION | ( | VOID | , |
| VerifyPreProcessSendAndForget | |||
| ) |
◆ FX_DECLARE_VF_FUNCTION_P1() [1/3]
| FxRequest::FX_DECLARE_VF_FUNCTION_P1 | ( | NTSTATUS | , |
| VerifyInsertIrpQueue | , | ||
| _In_ FxIrpQueue * | |||
| ) |
◆ FX_DECLARE_VF_FUNCTION_P1() [2/3]
◆ FX_DECLARE_VF_FUNCTION_P1() [3/3]
◆ GetCsqContext()
|
inline |
◆ GetCurrentIrpStackLocation()
|
inline |
Definition at line 1026 of file fxrequest.hpp.
1029 {
1034
1039 }
1040 else {
1042 }
1044
1046 }
1047 else {
1049 }
1050 }
PIO_STACK_LOCATION GetCurrentIrpStackLocation(VOID)
Definition: fxirpum.cpp:370
Referenced by FxIoQueue::DispatchRequestToDriver(), and FxIoQueue::GetRequest().
◆ GetCurrentQueue()
|
inline |
Definition at line 728 of file fxrequest.hpp.
Referenced by PerfIoComplete(), PerfIoStart(), and FxIoQueue::Requeue().
◆ GetDevice()
Definition at line 600 of file fxrequest.hpp.
◆ GetDeviceControlOutputMdl()
| _Must_inspect_result_ NTSTATUS FxRequest::GetDeviceControlOutputMdl | ( | __out PMDL * | pMdl | ) |
Definition at line 347 of file fxrequestkm.cpp.
392{
398 PMDL pNewMdl;
400
401 length = 0;
404
406
407 // Verifier
409
414 }
415 }
416
417 //
418 // See if we have an IRP_MJ_DEVICE_CONTROL or IRP_MJ_INTERNAL_DEVICE_CONTROL
419 //
421
425
426 //
427 // It's a non-Device Control request, which is an error for this call
428 //
429 DoTraceLevelMessage(
431 "WDFREQUEST %p (MajorFunction is 0x%x) this call is only valid for "
433 *pMdl = NULL;
434
436
438 }
439
442
445
446 // Fall through to common buffer handler
447 break;
448
450 //
451 // InputBuffer is in SystemBuffer
452 // OutputBuffer is in MdlAddress with read access
453 //
455
458
459 DoTraceLevelMessage(
461 "WDFREQUEST 0x%p, METHOD_IN_DIRECT IOCTL, PMDL is NULL, "
463 }
464 else {
466 }
468
470
472 //
473 // InputBuffer is in SystemBuffer
474 // OutputBuffer is in MdlAddress with write access
475 //
477
480
481 DoTraceLevelMessage(
483 "WDFREQUEST 0x%p, METHOD_OUT_DIRECT IOCTL, PMDL is NULL, "
485 }
486 else {
488 }
490
492
495
496 DoTraceLevelMessage(
498 "Attempt to get UserMode Buffer Pointer for METHOD_NEITHER "
499 "DeviceControl 0x%x, WDFDEVICE 0x%p, WDFREQUEST 0x%p, %!STATUS!",
502
503 DoTraceLevelMessage(
505 "Driver must use METHOD_BUFFERED or METHOD_xx_DIRECT I/O for this "
506 "call, or use WdfDeviceInitSetIoInCallerContextCallback to probe "
507 "and lock user mode memory");
508
509 *pMdl = NULL;
511
513 }
514
515 //
516 // if pBuffer != NULL, attempt to generate an MDL for it
517 //
519 *pMdl = NULL;
520
522
524
526 DoTraceLevelMessage(
528 "WDFREQUEST 0x%p, SystemBuffer is NULL, %!STATUS!",
530 }
532 DoTraceLevelMessage(
534 "WDFREQUEST 0x%p, SystemBuffer length is 0, %!STATUS!",
536 }
537
539 }
540
541 //
542 // See if we have already allocated an MDL for this
543 //
545 *pMdl = m_AllocatedMdl;
547
549 }
550
552 this,
553 pBuffer,
554 length,
555 FALSE,
556 FALSE);
557
560
561 DoTraceLevelMessage(
563 "WDFREQUEST %p could not allocate MDL for buffer 0x%p Length %d, "
565 *pMdl = NULL;
567
569 }
570
571 Mx::MxBuildMdlForNonPagedPool(pNewMdl);
572
573 //
574 // We associated the Mdl with the request object
575 // so it can be freed when completed.
576 //
577 m_AllocatedMdl = pNewMdl;
578
579 *pMdl = pNewMdl;
580
582
584}
static __inline VOID MxBuildMdlForNonPagedPool(__inout PMDL Mdl)
Definition: mxgeneralkm.h:376
PMDL FORCEINLINE FxMdlAllocate(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Owner, __in PVOID VirtualAddress, __in ULONG Length, __in BOOLEAN SecondaryBuffer, __in BOOLEAN ChargeQuota)
Definition: fxmdl.h:31
Referenced by switch().
◆ GetDeviceControlOutputMemoryObject()
| _Must_inspect_result_ NTSTATUS FxRequest::GetDeviceControlOutputMemoryObject | ( | __deref_out IFxMemory ** | MemoryObject, |
| __out PVOID * | Buffer, | ||
| __out size_t * | Length | ||
| ) |
Definition at line 1524 of file fxrequest.cpp.
1579{
1583 BOOLEAN mapMdl;
1585
1588
1590 length = 0;
1592 mapMdl = FALSE;
1593
1594 //
1595 // Verifier
1596 //
1601 }
1602 }
1603
1606 }
1607
1608 //
1609 // See if we already have a validated buffer
1610 //
1611 //if (m_RequestBaseFlags & FxRequestBaseOutputBufferValid) {
1612 // status = STATUS_SUCCESS;
1613 //}
1614
1616
1619
1621
1624
1625 DoTraceLevelMessage(
1627 "WDFREQUEST 0x%p IOCTL output buffer length is zero, %!STATUS!",
1629
1630 goto Done;
1631 }
1632
1634 //
1635 // InputBuffer is in SystemBuffer
1636 // OutputBuffer is in MdlAddress with read access
1637 //
1639 // || || fall || ||
1640 // \/ \/ through \/ \/
1641
1642 //
1643 // InputBuffer is in SystemBuffer
1644 // OutputBuffer is in MdlAddress with read access
1645 //
1647 mapMdl = TRUE;
1648 break;
1649
1651 //
1652 // Internal device controls are kernel mode to kernel mode, and deal
1653 // with direct unmapped pointers.
1654 //
1655 // In addition, a normal device control with
1656 // RequestorMode == KernelMode is also treated as kernel mode
1657 // to kernel mode since the I/O Manager will not generate requests
1658 // with this setting from a user mode request.
1659 //
1662 DO_NOTHING();
1663 }
1664 else {
1666
1667 DoTraceLevelMessage(
1669 "Attempt to get UserMode Buffer Pointer for "
1670 "METHOD_NEITHER DeviceControl 0x%x, WDFDEVICE 0x%p, "
1671 "WDFREQUEST 0x%p, %!STATUS!",
1674
1675 DoTraceLevelMessage(
1677 "Driver must use METHOD_BUFFERED or METHOD_xx_DIRECT "
1678 "I/O for this call, or use "
1679 "WdfDeviceInitSetIoInCallerContextCallback to probe and "
1680 "lock user mode memory");
1681 }
1682 break;
1683 }
1684
1686 PMDL pMdl;
1687 PVOID pVA;
1688
1689
1691
1693 //
1694 // Zero length transfer
1695 //
1697
1698 DoTraceLevelMessage(
1700 "WDFREQUEST 0x%p, METHOD_IN_DIRECT IOCTL PMDL is NULL, "
1702
1703 ASSERT(
1705 );
1706 }
1707 else {
1708 //
1709 // PagePriority may need to be a property, and/or parameter to
1710 // this call
1711 //
1712 //
1713 // Upon success, MmGetSystemAddressForMdlSafe stores the mapped
1714 // VA pointer in the pMdl and upon subsequent calls to
1715 // MmGetSystemAddressForMdlSafe, no mapping is done, just
1716 // the stored VA is returned. FxRequestOutputBuffer relies
1717 // on this behavior and, more importantly, relies on this function
1718 // to do the initial mapping so that FxRequestOutputBuffer::GetBuffer()
1719 // will not return a NULL pointer.
1720 //
1722
1725
1726 DoTraceLevelMessage(
1728 "WDFREQUEST 0x%p could not get a system address for PMDL"
1730 }
1731 else {
1735 }
1736 }
1737 }
1738
1739Done:
1742 }
1743
1746 if (mapMdl) {
1748 NormalPagePriority);
1749 }
1750 else {
1752 }
1754 }
1755
1757}
Definition: bufpool.h:45
static __inline PVOID MxGetSystemAddressForMdlSafe(__inout PMDL Mdl, __in ULONG Priority)
Definition: mxgeneralkm.h:366
_Must_inspect_result_ _In_ WDFREQUEST _In_ size_t _Out_ WDFMEMORY * MemoryObject
Definition: wdfrequest.h:1473
Referenced by if().
◆ GetFileObject()
| _Must_inspect_result_ NTSTATUS FxRequest::GetFileObject | ( | __deref_out_opt FxFileObject ** | pFileObject | ) |
Definition at line 2408 of file fxrequest.cpp.
2411{
2413 FxFileObject* pFileObject;
2416
2417 pFileObject = NULL;
2419
2421
2425
2428
2432 }
2433
2434 }
2435
2438 //
2439 // This is a 'must_complete' driver created request.
2440 //
2443 }
2444
2446 pDevice,
2449 &pFileObject
2450 );
2451
2453 *FileObject = pFileObject;
2455 }
2458 //
2459 // Driver told us that it is ok for the file object to be NULL.
2460 //
2463 }
2464 else {
2466 }
2467}
__inline WDF_FILEOBJECT_CLASS GetFileObjectClass(VOID)
Definition: fxdevice.hpp:1123
Definition: fxfileobject.hpp:29
static _Must_inspect_result_ NTSTATUS _GetFileObjectFromWdm(__in FxDevice *pDevice, __in WDF_FILEOBJECT_CLASS FileObjectClass, __in_opt MdFileObject pWdmFileObject, __deref_out_opt FxFileObject **ppFxFileObject)
Definition: fxfileobject.cpp:279
BOOLEAN __inline IsAllocatedDriver(VOID)
Definition: fxrequestbase.hpp:577
BOOLEAN __inline FxIsFileObjectOptional(__in WDF_FILEOBJECT_CLASS FileObjectClass)
Definition: fxdevice.hpp:112
◆ GetFxIrp()
Definition at line 957 of file fxrequest.hpp.
Referenced by FxIoQueue::DispatchRequestToDriver(), FxPkgIo::EnqueueRequest(), FxRequestSystemBuffer::GetBuffer(), FxRequestOutputBuffer::GetBuffer(), FxRequestSystemBuffer::GetBufferSize(), FxRequestOutputBuffer::GetBufferSize(), FxRequestSystemBuffer::GetFlags(), FxRequestOutputBuffer::GetFlags(), FxRequestSystemBuffer::GetMdl(), FxRequestOutputBuffer::GetMdl(), FxIoQueue::GetRequest(), PerfIoComplete(), PerfIoStart(), and FxIoQueue::QueueRequest().
◆ GetInformation()
Definition at line 277 of file fxrequest.cpp.
296{
298
300
301 // Verifier
306
308
312 }
313 else {
315 }
316
318
320 }
321 else {
323 }
324}
Definition: notification.c:61
◆ GetInternalContext()
Definition at line 1492 of file fxrequest.hpp.
Referenced by FxPkgIo::EnqueueRequest().
◆ GetIoQueue()
Definition at line 966 of file fxrequest.hpp.
◆ GetIrp()
|
inline |
Definition at line 975 of file fxrequest.hpp.
Referenced by Impersonate(), and FxIoQueue::QueueRequest().
◆ GetListEntry()
|
inline |
Definition at line 475 of file fxrequest.hpp.
478 {
484 }
485 }
Referenced by FxIoQueue::CancelForDriver().
◆ GetMdl()
| _Must_inspect_result_ NTSTATUS FxRequest::GetMdl | ( | __out PMDL * | pMdl | ) |
Definition at line 80 of file fxrequestkm.cpp.
83{
84 WDF_DEVICE_IO_TYPE ioType;
90 PMDL pNewMdl;
92
94 length = 0;
96
98
99 // Verifier
101
106 }
107 }
108
109 //
110 // See if we have an IRP_MJ_DEVICE_CONTROL or IRP_MJ_INTERNAL_DEVICE_CONTROL
111 //
113
116
121
122 // Fall through to common buffer handler
123 break;
124
126 //
127 // InputBuffer is in SystemBuffer
128 // OutputBuffer is in MdlAddress with read access
129 //
132
133 // Fall through to common buffer handler
134 break;
135
137 //
138 // InputBuffer is in SystemBuffer
139 // OutputBuffer is in MdlAddress with write access
140 //
143
144 // Fall through to common buffer handler
145
146 break;
147
149 default:
151 DoTraceLevelMessage(
153 "Attempt to get UserMode MDL for METHOD_NEITHER DeviceControl 0x%x, "
154 "WDFDEVICE 0x%p, WDFREQUEST 0x%p, %!STATUS!",
157
158 DoTraceLevelMessage(
160 "Driver must use METHOD_BUFFERED or METHOD_xx_DIRECT "
161 "I/O for this call, or use "
162 "WdfDeviceInitSetIoInCallerContextCallback to probe "
163 "and lock user mode memory");
164
165 *pMdl = NULL;
167
169 }
170 }
171 else {
172 //
173 // It's a non-Device Control request, we must know the devices I/O type in
174 // order to safely return the correct buffer
175 //
176 ioType = GetDevice()->GetIoType();
177
179
181
182 //
183 // Must get the length depending on the request type code
184 //
187 }
190 }
191 else {
192 //
193 // Report the error, we can support other IRP_MJ_xxx codes are required
194 // later
195 //
197
198 DoTraceLevelMessage(
200 "WDFREQUEST %p no Automatic MDL mapping for buffered request"
201 "major function 0x%x available for WDFDEVICE 0x%p, %!STATUS!",
203 status);
204
205 *pMdl = NULL;
206
208
210 }
211
212 // Fall through to common buffer handler
213 }
215
216 //
217 // If driver has used the default DO_DIRECT_IO I/O Mgr has done all the work
218 //
220
223
224 DoTraceLevelMessage(
226 "WDFREQUEST 0x%p for a direct io device, PMDL is NULL, "
228 }
229 else {
231 }
232
234
236 }
239
240 DoTraceLevelMessage(
242 "Attempt to get UserMode Buffer Pointer for "
243 "WDFDEVICE 0x%p, WDFREQUEST 0x%p, %!STATUS!",
245
246 DoTraceLevelMessage(
248 "Driver must use buffered or direct I/O for this "
249 "call, or use WdfDeviceInitSetIoInCallerContextCallback "
250 "to probe and lock user mode memory");
252
253 *pMdl = NULL;
255
257 }
258 else {
260
261 DoTraceLevelMessage(
263 "Unrecognized I/O Type %d on WDFDEVICE 0x%p, WDFREQUEST 0x%p, "
264 "%!STATUS!",
267
268 *pMdl = NULL;
270
272 }
273 }
274
275 //
276 // if pBuffer != NULL, attempt to generate an MDL for it
277 //
279 *pMdl = NULL;
281
283
285 DoTraceLevelMessage(
287 "WDFREQUEST 0x%p, SystemBuffer is NULL, %!STATUS!",
289 }
291 DoTraceLevelMessage(
293 "WDFREQUEST 0x%p, SystemBuffer length is 0, %!STATUS!",
295 }
296
298 }
299
300 //
301 // See if we have already allocated an MDL for this
302 //
304 *pMdl = m_AllocatedMdl;
307 }
308
310 this,
311 pBuffer,
312 length,
313 FALSE,
314 FALSE);
315
318
319 DoTraceLevelMessage(
321 "Could not allocate MDL for buffer 0x%p Length %d, %!STATUS!",
323 *pMdl = NULL;
325
327 }
328
329 Mx::MxBuildMdlForNonPagedPool(pNewMdl);
330
331 //
332 // We associated the Mdl with the request object
333 // so it can be freed when completed.
334 //
335 m_AllocatedMdl = pNewMdl;
336
337 *pMdl = pNewMdl;
338
340
342}
ULONG GetParameterIoctlInputBufferLength(VOID)
Definition: fxirpum.cpp:1518
enum _WDF_DEVICE_IO_TYPE WDF_DEVICE_IO_TYPE
Referenced by switch().
◆ GetMemoryHandle()
Definition at line 658 of file fxrequest.hpp.
661 {
663
664 //
665 // The offset into this object must be self relative.
666 //
668
670
671 //
672 // Make sure initial value has the flag bits cleared.
673 //
675
676 //
677 // We always apply the mask.
678 //
680
681 //
682 // Make sure final value (before we set the flag) has the flag bits
683 // cleared.
684 //
686
687 //
688 // This handle is an offset
690
692 }
DECLSPEC_SELECTANY const ULONG_PTR FxHandleValueMask
Definition: rpc_generic.c:61
Referenced by FxRequestSystemBuffer::GetHandle(), and FxRequestOutputBuffer::GetHandle().
◆ GetMemoryObject()
| _Must_inspect_result_ NTSTATUS FxRequest::GetMemoryObject | ( | __deref_out IFxMemory ** | Memory, |
| __out PVOID * | Buffer, | ||
| __out size_t * | Length | ||
| ) |
Definition at line 1284 of file fxrequest.cpp.
1289{
1290 PMDL pMdl;
1294 BOOLEAN mapMdl;
1296
1298 length = 0x0;
1299 mapMdl = FALSE;
1302
1303
1304 //
1305 // Verifier
1306 //
1310 goto Done;
1311 }
1313 &&
1316 &&
1319
1320 DoTraceLevelMessage(
1322 "Attempt to get UserMode Buffer Pointer for WDFDEVICE 0x%p, "
1323 "WDFREQUEST 0x%p, %!STATUS!",
1325
1326 DoTraceLevelMessage(
1328 "Driver must use buffered or direct I/O for this call, or use "
1329 "WdfDeviceInitSetIoInCallerContextCallback to probe and lock "
1330 "user mode memory");
1331
1333 }
1334 }
1335
1338 }
1339
1340 //
1341 // We must dig into the IRP to get the buffer, length, and readonly status
1342 //
1343
1348
1351
1352 DoTraceLevelMessage(
1354 "WDFREQUEST %p InputBufferLength length is zero, %!STATUS!",
1356
1357 goto Done;
1358 }
1359
1361 //
1362 // Internal device controls are kernel mode to kernel mode, and deal
1363 // with direct unmapped pointers.
1364 //
1365 // In addition, a normal device control with
1366 // RequestorMode == KernelMode is also treated as kernel mode
1367 // to kernel mode since the I/O Manager will not generate requests
1368 // with this setting from a user mode request.
1369 //
1372 DO_NOTHING();
1373 }
1374 else {
1376
1377 DoTraceLevelMessage(
1379 "Attempt to get UserMode Buffer Pointer for METHOD_NEITHER "
1380 "DeviceControl 0x%x, WDFDEVICE 0x%p, WDFREQUEST 0x%p, "
1381 "%!STATUS!",
1384
1385 DoTraceLevelMessage(
1387 "Driver must use METHOD_BUFFERED or METHOD_xx_DIRECT I/O for "
1388 "this call, or use WdfDeviceInitSetIoInCallerContextCallback to "
1389 "probe and lock user mode memory %!STATUS!",
1391
1392 goto Done;
1393 }
1394 }
1395 break;
1396
1399
1401 KMDF_ONLY_CODE_PATH_ASSERT();
1402 mapMdl = TRUE;
1403 }
1404 break;
1405
1408
1410 KMDF_ONLY_CODE_PATH_ASSERT();
1411 mapMdl = TRUE;
1412 }
1413 break;
1414
1415 default:
1416 DoTraceLevelMessage(
1418 "Unrecognized Major Function 0x%x on WDFDEVICE 0x%p WDFREQUEST 0x%p",
1420
1422
1424 goto Done;
1425 }
1426
1429
1430 DoTraceLevelMessage(
1432 "WDFREQUEST 0x%p length is zero, %!STATUS!",
1434
1435 goto Done;
1436 }
1437
1438 //
1439 // See if we need to map
1440 //
1443
1445 //
1446 // Zero length transfer
1447 //
1449
1450 DoTraceLevelMessage(
1452 "WDFREQUEST 0x%p, direct io device, PMDL is NULL, "
1454
1456 }
1457 else {
1458 PVOID pVA;
1459
1460 //
1461 // PagePriority may need to be a property, and/or parameter to
1462 // this call
1463 //
1464 //
1465 // Upon success, MmGetSystemAddressForMdlSafe stores the mapped
1466 // VA pointer in the pMdl and upon subsequent calls to
1467 // MmGetSystemAddressForMdlSafe, no mapping is done, just
1468 // the stored VA is returned. FxRequestSystemBuffer relies
1469 // on this behavior and, more importantly, relies on this function
1470 // to do the initial mapping so that FxRequestSystemBuffer::GetBuffer()
1471 // will not return a NULL pointer.
1472 //
1474
1477
1478 DoTraceLevelMessage(
1480 "WDFREQUEST 0x%p could not get a system address for PMDL "
1482 }
1483 else {
1484 //
1485 // System will automatically release the mapping PTE's when
1486 // the MDL is released by the I/O request
1487 //
1488
1489
1490
1491
1492
1494
1496 }
1497 }
1498 }
1499
1500Done:
1503 }
1504
1507
1508 if (mapMdl) {
1510 NormalPagePriority);
1511 }
1512 else {
1514 }
1515
1517 }
1518
1520}
◆ GetNextRequest() [1/2]
|
static |
Definition at line 2025 of file fxrequest.cpp.
2028{
2032
2034
2037 }
2038
2039 // Irp is not cancellable now
2041
2042 // Must tell the request it's off the queue
2044
2045 // Remove reference placed when on IrpQueue
2047
2049}
static __inline FxRequest * RetrieveFromCsqContext(__in PMdIoCsqIrpContext pCsqContext)
Definition: fxrequest.hpp:1163
__inline VOID MarkRemovedFromIrpQueue(VOID)
Definition: fxrequest.hpp:1100
Definition: csq.h:84
Referenced by _Releases_lock_(), FxIoQueue::FlushByFileObject(), FxIoQueue::GetRequest(), FxIoQueue::QueueIdle(), and FxIoQueue::QueuePurge().
◆ GetNextRequest() [2/2]
|
static |
Definition at line 2057 of file fxrequest.cpp.
2063{
2066 PMdIoCsqIrpContext TagCsqContext;
2067
2069 TagCsqContext = TagRequest->GetCsqContext();
2070 }
2071 else {
2072 TagCsqContext = NULL;
2073 }
2074
2078 }
2079
2080 // Irp is not cancellable now
2081
2082 // Must tell the request its off the queue
2084
2085 // Remove reference placed when on IrpQueue
2087
2088 *ppOutRequest = pRequest;
2089
2091}
◆ GetParameters()
| _Must_inspect_result_ NTSTATUS FxRequest::GetParameters | ( | __out PWDF_REQUEST_PARAMETERS | Parameters | ) |
Definition at line 1221 of file fxrequest.cpp.
1224{
1226
1228
1229 //
1230 // No lock needed. Only reason this may be invalid is due
1231 // to previous completion, which is a serious driver bug
1232 // that will result in a crash anyway.
1233 //
1234
1238
1240
1244 }
1245
1247
1250 }
1251 }
1252
1254
1255 // How much we copied
1257
1258
1259 // Copy parameters
1262
1263 // Copy the Parameters structure which we are a subset of
1265
1267 //
1268 // If verifier is on, and the operation is an IRP_MJ_DEVICE_CONTROL
1269 // with METHOD_NEITHER, then set Type3InputBuffer to zero since
1270 // this should not be used to pass parameters in the normal path
1271 //
1275 }
1276 }
1277
1279}
VOID CopyParameters(_Out_ PWDF_REQUEST_PARAMETERS Parameters)
Definition: fxirpum.cpp:1691
enum _WDF_REQUEST_TYPE WDF_REQUEST_TYPE
struct _WDF_REQUEST_PARAMETERS WDF_REQUEST_PARAMETERS
◆ GetRequestorMode()
| KPROCESSOR_MODE FxRequest::GetRequestorMode | ( | VOID | ) |
Definition at line 327 of file fxrequest.cpp.
342{
344
346
351
353
357 } else {
359 }
360
362
364 }
365 else {
367 }
368}
◆ GetStatus()
Definition at line 1187 of file fxrequest.cpp.
1190{
1193
1195
1198
1200
1201
1202
1203
1204
1205
1206
1207
1209
1211
1213 }
1214 else {
1216 }
1217}
◆ Impersonate()
| NTSTATUS FxRequest::Impersonate | ( | _In_ SECURITY_IMPERSONATION_LEVEL | ImpersonationLevel, |
| _In_ PFN_WDF_REQUEST_IMPERSONATE | EvtRequestImpersonate, | ||
| _In_opt_ PVOID | Context | ||
| ) |
Definition at line 226 of file fxrequestum.cpp.
231{
232 DDI_ENTRY();
233
237
241 "WDFREQUEST is already completed 0x%p, %!STATUS!",
245 }
246
248
252 irp->RevertImpersonation();
253 }
254 else {
257 "WDFREQUEST 0x%p, Could not impersonate, %!STATUS!",
259 }
260
262}
_Must_inspect_result_ NTSTATUS GetIrp(__deref_out MdIrp *ppIrp)
Definition: fxrequest.hpp:975
_Must_inspect_result_ _In_ WDFREQUEST _In_ SECURITY_IMPERSONATION_LEVEL _In_ PFN_WDF_REQUEST_IMPERSONATE EvtRequestImpersonate
Definition: fxrequestapium.cpp:41
Definition: mshtmhst.idl:286
Definition: compobj.c:4795
_Out_ PBOOLEAN _Out_ PBOOLEAN _Out_ PSECURITY_IMPERSONATION_LEVEL ImpersonationLevel
Definition: psfuncs.h:156
◆ InsertHeadIrpQueue()
| _Must_inspect_result_ NTSTATUS FxRequest::InsertHeadIrpQueue | ( | __in FxIrpQueue * | IrpQueue, |
| __out_opt ULONG * | pRequestCount | ||
| ) |
Definition at line 1908 of file fxrequest.cpp.
1912{
1915
1917
1918 // No locking required since only one accessor till inserted on queue
1919
1923 }
1924
1925 //
1926 // If a request is on an IrpQueue, it must be referenced
1927 //
1928
1929
1930
1931
1932
1933
1935
1938
1940
1942 &m_CsqContext,
1943 pRequestCount);
1944
1945 //
1946 // If this insert failed, we must release the extra reference we took
1947 //
1949 MarkRemovedFromIrpQueue();
1951 }
1952
1954}
Referenced by FxIoQueue::Requeue().
◆ InsertTailIrpQueue()
| _Must_inspect_result_ NTSTATUS FxRequest::InsertTailIrpQueue | ( | __in FxIrpQueue * | IrpQueue, |
| __out_opt ULONG * | pRequestCount | ||
| ) |
Definition at line 1858 of file fxrequest.cpp.
1862{
1865
1867
1868 // No locking required since only one accessor till inserted on queue
1869
1873 }
1874
1875 //
1876 // If a request is on an IrpQueue, it must be referenced
1877 //
1878
1879
1880
1881
1882
1883
1885
1888
1890
1892 &m_CsqContext,
1893 pRequestCount);
1894
1895 //
1896 // If this insert failed, we must release the extra reference we took
1897 //
1899 MarkRemovedFromIrpQueue();
1901 }
1902
1904}
Referenced by FxIoQueue::QueueRequestFromForward(), and FxIoQueue::RequestCancelable().
◆ IsCancelled()
Definition at line 525 of file fxrequest.hpp.
528 {
530 }
◆ IsInIrpQueue()
|
inline |
Definition at line 1173 of file fxrequest.hpp.
◆ IsPowerStopAcknowledged()
Definition at line 1195 of file fxrequest.hpp.
◆ IsPowerStopAcknowledgedWithRequeue()
Definition at line 1206 of file fxrequest.hpp.
1209 {
1211 }
◆ IsRequestForwardedToParent()
Definition at line 1316 of file fxrequest.hpp.
Referenced by FxRequestFromLookaside::SelfDestruct().
◆ IsReserved()
|
inline |
Definition at line 609 of file fxrequest.hpp.
Referenced by CompleteInternal(), PostProcessSendAndForget(), PreProcessSendAndForget(), FxIoQueue::QueueRequest(), and Release().
◆ MarkRemovedFromIrpQueue()
Definition at line 1100 of file fxrequest.hpp.
Referenced by FxIoQueue::CancelForDriver(), GetNextRequest(), InsertHeadIrpQueue(), InsertTailIrpQueue(), and RemoveFromIrpQueue().
◆ PeekRequest()
|
static |
Definition at line 2098 of file fxrequest.cpp.
2105{
2107
2109
2110 //
2111 // IrpQueue::PeekRequest works with CSQ_CONTEXT
2112 // structures since this is the only value that
2113 // is valid across cancellation.
2114 //
2116 TagContext = TagRequest->GetCsqContext();
2117 }
2118
2120 TagContext,
2121 FileObject,
2122 ppOutRequest
2123 );
2125
2128 }
2129 }
2130
2132}
Referenced by FxIoQueue::PeekRequest(), and FxIoQueue::QueueIdle().
◆ PostProcessCompletion()
|
private |
Definition at line 874 of file fxrequest.cpp.
878{
879 //
880 // Fire frameworks internal callback event if one is set
881 // (FxIoQueue or IoTarget's internal use)
882 //
884 //
885 // NOTE: This occurs after the IRP has already been released,
886 // and is only used for notification that the request
887 // has completed.
888 //
891 }
892 else {
895 //FxIoQueueToMx::RequestCompletedCallback(Queue, this);
896 }
897
898 //
899 // DeleteObject will dereference the object reference taken when the callback
900 // was registered
901 //
902 DeleteEarlyDisposedObject();
903 }
904 else {
905 //
906 // Caller still wants the FxRequest class to be valid on return,
907 // but must call DeleteObject in order to ensure the object is
908 // no longer assigned any child objects, etc.
909 //
911 DeleteObject();
912 }
913}
VOID DeleteEarlyDisposedObject(VOID)
Definition: fxobjectstatemachine.cpp:172
@ FxRequestCompletionStateIoPkgFlag
Definition: fxrequestbase.hpp:159
Definition: stack_allocator.h:18
Referenced by CompleteInternal(), and PostProcessSendAndForget().
◆ PostProcessCompletionForDriverRequest()
|
private |
Definition at line 996 of file fxrequest.cpp.
1000{
1001 //
1002 // NOTE: Do not touch the request object here. The request object may already be
1003 // re-used or deleted.
1004 //
1005
1008 //
1009 // Fire frameworks internal callback (post) event if one is set.
1010 //
1012 //
1013 // NOTE: This occurs after the IRP has already been released, and is only used
1014 // to notify the queue to update its internal state and if appropriate, send
1015 // another request.
1016 //
1018 }
1019}
Referenced by Release().
◆ PostProcessCompletionForReserved()
|
private |
Definition at line 916 of file fxrequest.cpp.
920{
921 //
922 // Fire frameworks internal callback event if one is set
923 // (FxIoQueue or IoTarget's internal use)
924 //
926 //
927 // NOTE: This occurs after the IRP has already been released,
928 // and is only used for notification that the request
929 // has completed.
930 //
933 }
934 else {
937 }
938 }
939 else {
940 //
941 // Caller still wants the FxRequest class to be valid on return,
942 // but must call DeleteObject in order to ensure the object is
943 // no longer assigned any child objects, etc.
944 //
946 }
947
949}
Referenced by CompleteInternal(), and PostProcessSendAndForget().
◆ PostProcessSendAndForget()
Definition at line 1149 of file fxrequest.cpp.
1152{
1155
1157
1158 //
1159 // Capture the m_IoQueue value before making any other calls.
1160 // Note: m_IoQueue could be NULL if the request is freed before it's queued.
1161 //
1163
1165
1168
1169 //
1170 // Technically we did not complete the irp, but a send and forget is
1171 // functionally the same. We no longer own the irp.
1172 //
1175 }
1176 else {
1177 //
1178 // Release checks m_Completed flag to decide whether to return
1179 // the request to reserved pool.
1180 //
1183 }
1184}
Referenced by FxPkgIo::EnqueueRequest().
◆ PreProcessCompletionForDriverRequest()
|
private |
Definition at line 955 of file fxrequest.cpp.
959{
962 //
963 // Fire frameworks internal callback (pre) event if one is set.
964 //
966 //
967 // NOTE: This occurs before the IRP has already been released,
968 // and is only used to notify the queue to remove this request from this queue's
969 // internal lists. A second notification (lPostProcessCompletionForAllocatedDriver)
970 // is made after the IRP is completed.
971 //
973 }
975 //
976 // On return from PostProcessCompletionForDriverRequest, caller (framework)
977 // will try to release the last ref. Increase the ref count so request stays alive until
978 // driver invokes WdfObjectDelete on this request.
979 //
981 }
982
983 //
984 // Let the system know that it is OK to complete this request.
985 //
987}
Referenced by CompleteInternal().
◆ PreProcessSendAndForget()
Definition at line 1101 of file fxrequest.cpp.
1104{
1105 VerifyPreProcessSendAndForget(GetDriverGlobals());
1106
1107 //
1108 // To be sent and forgotten, the irp must have been presented
1109 //
1111
1112 //
1113 // To be sent and forgotten, the irp must not have a formatted IO context.
1114 //
1116
1117 //
1118 // If the driver writer setup the next stack location using the current
1119 // stack location or did a manual IO_STACK_LOCATION copy, we do not want to
1120 // skip the current stack location that their format is used by the target
1121 // driver.
1122 //
1125 }
1126
1128
1129 //
1130 // If a cleanup callback has been registered, we call it
1131 // just before sending the IRP on its way. The contract is that the cleanup
1132 // routine for a WDFREQUEST is called while the PIRP is still valid.
1133 //
1135 VerifierBreakpoint_RequestEarlyDisposeDeferred(GetDriverGlobals());
1136 }
1137
1138 //
1139 // Now that the entire tree is disposed, we want to destroy all of the
1140 // children. This will not put this object in the destroyed state. For
1141 // m_IrpReferenceCount to go to zero, we need to destroy the child WDFMEMORYs
1142 // that were created when we probed and locked the buffers.
1143 //
1144 DestroyChildren();
1145 }
1146}
BOOLEAN m_NextStackLocationFormatted
Definition: fxrequestbase.hpp:795
Referenced by FxPkgIo::EnqueueRequest().
◆ ProbeAndLockForRead()
| _Must_inspect_result_ NTSTATUS FxRequest::ProbeAndLockForRead | ( | __in PVOID | Buffer, |
| __in ULONG | Length, | ||
| __deref_out FxRequestMemory ** | pMemoryObject | ||
| ) |
Definition at line 588 of file fxrequestkm.cpp.
625{
627 PMDL pMdl;
629 PVOID pVA;
632
633 pMdl = NULL;
636
639
640 DoTraceLevelMessage(
643
645 }
646
648
651
652 // Error, completed request
653 DoTraceLevelMessage(
655 "WDFREQUEST %p has already been completed or has no PIRP assignment,"
657
659
661 }
662
663 //
664 // Look at the Irp, and if there is a thread field, validate we are
665 // actually in the correct process!
666 //
670 }
671
673
679 }
680
681 // Use a C utility function for the probe due to C++ exception handling issues
683
686 "Exception is raised for Address 0x%p, Length %d %!STATUS!",
690 }
691
692 //
693 // Get a system address for the MDL
694 //
698 goto Done;
699 }
700
701 // Build an FxRequestMemory object now
704 goto Done;
705 }
706
707 // Associate the FxRequestMemory object with the FxRequest
710 goto Done;
711 }
712
713Done:
715 //
716 // If we re-define the WDFMEMORY interfaces to allow
717 // failure for get buffer, we could delay the assignment
718 // of SystemAddressForMdl and its PTE's until the driver
719 // actually requests a double buffer mapping.
720 //
721 // Some DMA drivers may just retrieve the MDL from the WDFMEMORY
722 // and not even attempt to access the underlying bytes, other
723 // than through hardware DMA.
724 //
725 pMemory->SetMdl(
726 this,
727 pMdl,
728 pVA,
729 Length,
731 );
732
734 }
735 else {
738 }
739
740 Mx::MxUnlockPages(pMdl);
742 }
743
745}
Definition: fxrequestmemory.hpp:33
static NTSTATUS Create(__in PFX_DRIVER_GLOBALS DriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out FxRequestMemory **Object)
Definition: fxrequestmemory.cpp:54
VOID __inline FxMdlFree(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PMDL Mdl)
Definition: fxmdl.h:60
NTSTATUS FxProbeAndLockForRead(__in PMDL Mdl, __in KPROCESSOR_MODE AccessMode)
Definition: probeandlock.c:36
Definition: Bus_PDO_EvalMethod.c:105
◆ ProbeAndLockForWrite()
| _Must_inspect_result_ NTSTATUS FxRequest::ProbeAndLockForWrite | ( | __in PVOID | Buffer, |
| __in ULONG | Length, | ||
| __deref_out FxRequestMemory ** | pMemoryObject | ||
| ) |
Definition at line 749 of file fxrequestkm.cpp.
786{
788 PMDL pMdl;
790 PVOID pVA;
793
794 pMdl = NULL;
797
800
801 DoTraceLevelMessage(
804
806 }
807
809
812
813 // Error, completed request
814 DoTraceLevelMessage(
816 "WDFREQUEST %p has already been completed or has no PIRP assignment,"
818
820
822 }
823
824 //
825 // Look at the Irp, and if there is a thread field, validate we are
826 // actually in the correct process!
827 //
831 }
832
839 }
840
841 // Use a C utility function for the probe due to C++ exception handling issues
843
846 "Exception is raised for Address 0x%p, Length %d %!STATUS!",
850 }
851
852 //
853 // Get a system address for the MDL
854 //
858 goto Done;
859 }
860
861 // Build an FxRequestMemory object now
864 goto Done;
865 }
866
867 // Associate the FxRequestMemory object with the FxRequest
870 goto Done;
871 }
872
873Done:
875 //
876 // If we re-define the WDFMEMORY interfaces to allow
877 // failure for get buffer, we could delay the assignment
878 // of SystemAddressForMdl and its PTE's until the driver
879 // actually requests a double buffer mapping.
880 //
881 // Some DMA drivers may just retrieve the MDL from the WDFMEMORY
882 // and not even attempt to access the underlying bytes, other
883 // than through hardware DMA.
884 //
885 pMemory->SetMdl(
886 this,
887 pMdl,
888 pVA,
889 Length,
891 );
892
894 }
895 else {
898 }
899
900 Mx::MxUnlockPages(pMdl);
902 }
903
905}
NTSTATUS FxProbeAndLockForWrite(__in PMDL Mdl, __in KPROCESSOR_MODE AccessMode)
Definition: probeandlock.c:55
◆ QueryInterface()
|
protectedvirtual |
Reimplemented from FxObject.
Definition at line 2714 of file fxrequest.cpp.
2717{
2721 break;
2722
2726 break;
2727 }
2730 break;
2731 }
2732
2733 // || || Fall || ||
2734 // \/ \/ through \/ \/
2735 default:
2737 }
2738
2740}
virtual _Must_inspect_result_ NTSTATUS QueryInterface(__in FxQueryInterfaceParams *Params)
Definition: fxobject.cpp:255
Definition: ifxmemory.hpp:40
◆ Release()
Definition at line 3089 of file fxrequest.cpp.
3094{
3095 ULONG retValue;
3096 BOOLEAN reservedRequest;
3097 BOOLEAN allocFromIo;
3098 BOOLEAN canComplete;
3099
3100 //
3101 // This may be the last ref, copy flags before calling Release().
3102 //
3103 reservedRequest = IsReserved();
3104 allocFromIo = IsAllocatedFromIo();
3105 canComplete = IsCanComplete();
3106
3108
3110 //
3111 // Reserved requests should have an associated queue all the time.
3112 //
3114 }
3116
3119
3120 //
3121 // Make a local copy before request is gone.
3122 //
3125
3128
3129 //
3130 // We are now ready to complete this driver created request.
3131 //
3133
3135
3137
3139 }
3140
3141 return retValue;
3142}
VOID ReturnReservedRequest(__in FxRequest *ReservedRequest)
Definition: fxioqueueum.hpp:106
virtual ULONG Release(__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
Definition: fxobject.hpp:853
VOID PostProcessCompletionForDriverRequest(__in FxRequestCompletionState State, __in FxIoQueue *Queue)
Definition: fxrequest.cpp:996
◆ ReleaseIrpReference()
Definition at line 2512 of file fxrequest.cpp.
2530{
2532
2534
2537 "Attempt to release an IRP reference without adding "
2540 }
2541
2542 return;
2543}
Referenced by FxRequestSystemBuffer::Release(), FxRequestOutputBuffer::Release(), FxDmaTransactionBase::ReleaseButRetainRequest(), ReleaseOverride(), and FxRequestMemory::~FxRequestMemory().
◆ ReleaseOverride()
|
virtual |
Definition at line 2694 of file fxrequest.cpp.
◆ RemoveFromIrpQueue()
| _Must_inspect_result_ NTSTATUS FxRequest::RemoveFromIrpQueue | ( | __in FxIrpQueue * | IrpQueue | ) |
Definition at line 1961 of file fxrequest.cpp.
1964{
1967
1969
1970 //
1971 // Cancel Safe Queues allow this request
1972 // removal to be race free even if the
1973 // request has been cancelled already.
1974 //
1975 // It signals this by returning NULL for
1976 // the Irp.
1977 //
1979
1981
1982 //
1983 // Cancel routine removed it from the cancel
1984 // safe queue.
1985 //
1986 // The cancel handler will remove this reference
1987 // in FxIoQueue::_IrpCancelForDriver /
1988 // FxIrpQueue::_WdmCancelRoutineInternal
1989 //
1990
1992 }
1993 else {
1994
1995 //
1996 // We retrieved the Irp from the cancel safe queue
1997 // without it having been cancelled first.
1998 //
1999 // It is no longer cancelable
2000 //
2003 DoTraceLevelMessage(
2005 "WDFREQUEST 0x%p not on IrpQueue",
2006 GetHandle());
2007
2009 }
2010 }
2011
2012 MarkRemovedFromIrpQueue();
2013
2015
2017 }
2018}
Referenced by FxIoQueue::RequestCancelable().
◆ RetrieveFromCsqContext()
|
inlinestatic |
Definition at line 1163 of file fxrequest.hpp.
Referenced by GetNextRequest(), FxIrpQueue::GetNextRequest(), and FxIrpQueue::PeekRequest().
◆ Reuse()
| _Must_inspect_result_ NTSTATUS FxRequest::Reuse | ( | __in PWDF_REQUEST_REUSE_PARAMS | ReuseParams | ) |
Definition at line 2136 of file fxrequest.cpp.
2139{
2140 FxIrp currentIrp;
2142
2143 //
2144 // Make sure request is not pended in IoTarget.
2145 //
2149
2153 DoTraceLevelMessage(
2155 "Driver is trying to reuse WDFREQUEST 0x%p while it is still "
2156 "active on WDFIOTARGET 0x%p. ",
2159 }
2161 }
2162
2163 //
2164 // For drivers 1.9 and above (for maintaining backwards compatibility)
2165 // deregister previously registered completion routine.
2166 //
2169 }
2170
2172
2174 //
2175 // Release all outstanding references and restore original fields in
2176 // the PIRP
2177 //
2180 }
2181
2183 //
2184 // An irp presented by io queue can only reset a limited state
2185 //
2187 //
2188 // Not allowed to set a new irp
2189 //
2191 }
2192
2193#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
2196#else
2197 //
2198 // For UMDF, host sets cancel flag to false as part of Reuse(), so no
2199 // need to have a separate call for UMDF (that's why host irp doesn't
2200 // expose any interface to set this independently).
2201
2202
2203
2204
2205 //
2207#endif
2210
2212 }
2214 //
2215 // Release outstanding reference on a must complete driver request.
2216 //
2219
2222 }
2223
2225 }
2226 }
2227 }
2228 else {
2229 //
2230 // We should not have a m_RequestContext with anything to ReleaseAndRestore
2231 // because there is no IRP to have anything formatted off of.
2232 //
2233 DO_NOTHING();
2234 }
2235
2236 //
2237 // This cannot be a request on a queue
2238 //
2241
2244
2245 //
2246 // If we are replacing an internal irp, we must free it later.
2247 //
2249 MdIrp pOldIrp;
2250
2253
2255 FxIrp oldIrp(pOldIrp);
2256 oldIrp.FreeIrp();
2257 }
2258 }
2259 else {
2261 }
2262
2264 }
2265
2266 //
2267 // Only reinitialize an internal irp. If the irp is external, then its
2268 // still valid.
2269 //
2274
2275 //
2276 // For UMDF, host sets cancel flag to false as part of Reuse(), so no
2277 // need to have a separate call for UMDF (that's why host irp doesn't
2278 // expose any interface to set this independently).
2279
2280
2281
2282
2283 //
2284#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
2286#endif
2287 }
2288
2289 //
2290 // If necessary, reinit the request to support WdfRequestComplete.
2291 //
2294
2295 //
2296 // WDF guarantees a successful return code when the driver calls Reuse() from its
2297 // completion routine with valid input.
2298 //
2299
2300 //
2301 // This feature can only be used from WDF v1.11 and above.
2302 //
2305 DoTraceLevelMessage(
2307 "WDFREQUEST %p doesn't belong to any queue, %!STATUS!",
2311 }
2312
2313 //
2314 // 'must_complete' flag requires an IRP.
2315 //
2318 DoTraceLevelMessage(
2320 "Driver is trying to reuse WDFREQUEST 0x%p without "
2321 "specifying an IRP with "
2322 "WDF_REQUEST_REUSE_MUST_COMPLETE flag, %!STATUS!",
2326 }
2327
2328 //
2329 // Do not support internal IRPs.
2330 //
2333 DoTraceLevelMessage(
2335 "Driver is trying to reuse WDFREQUEST 0x%p holding an"
2336 "internal allocated IRP with "
2337 "WDF_REQUEST_REUSE_MUST_COMPLETE flag, %!STATUS!",
2341 }
2342
2343 //
2344 // Ref count must be 1.
2345 //
2348 DoTraceLevelMessage(
2350 "Driver is trying to reuse WDFREQUEST 0x%p with "
2351 "WDF_REQUEST_REUSE_MUST_COMPLETE flag while request is "
2352 "being referenced, reference count:%d, %!STATUS!",
2356 }
2357
2358 //
2359 // Make sure current IRP stack location is valid.
2360 //
2363 DoTraceLevelMessage(