trackirp.h File Reference

Go to the source code of this file.

Classes
struct	_IOFCALLDRIVER_STACKDATA
struct	_IOV_STACK_LOCATION
struct	_IOV_SESSION_DATA
struct	_IOV_REQUEST_PACKET
struct	_DEFERRAL_CONTEXT
struct	_IOFCOMPLETEREQUEST_STACKDATA
Defines
#define	ASSERTFLAG_TRACKIRPS   0x00000001
#define	ASSERTFLAG_MONITOR_ALLOCS   0x00000002
#define	ASSERTFLAG_POLICEIRPS   0x00000004
#define	ASSERTFLAG_MONITORMAJORS   0x00000008
#define	ASSERTFLAG_SURROGATE   0x00000010
#define	ASSERTFLAG_SMASH_SRBS   0x00000020
#define	ASSERTFLAG_CONSUME_ALWAYS   0x00000040
#define	ASSERTFLAG_FORCEPENDING   0x00000080
#define	ASSERTFLAG_COMPLETEATDPC   0x00000100
#define	ASSERTFLAG_COMPLETEATPASSIVE   0x00000200
#define	ASSERTFLAG_DEFERCOMPLETION   0x00000800
#define	ASSERTFLAG_ROTATE_STATUS   0x00001000
#define	ASSERTMASK_COMPLETESTYLE   0x00000F80
#define	ASSERTFLAG_SEEDSTACK   0x00010000
#define	HACKHACKS_ENABLED
#define	HACKFLAG_FOR_MUP   0x00000001
#define	HACKFLAG_FOR_SCSIPORT   0x00000002
#define	HACKFLAG_FOR_ACPI   0x00000004
#define	HACKFLAG_FOR_BOGUSIRPS   0x00000008
#define	IRPFLAG_EXAMINE_MASK   0xC0000000
#define	IRPFLAG_EXAMINE_NOT_TRACKED   0x80000000
#define	IRPFLAG_EXAMINE_TRACKED   0x40000000
#define	IRPFLAG_EXAMINE_UNMARKED   0x00000000
#define	IRP_DIAG_HAS_SURROGATE   0x02000000
#define	IRP_DIAG_IS_SURROGATE   0x01000000
#define	TRACKFLAG_ACTIVE   0x00000001
#define	TRACKFLAG_SURROGATE   0x00000002
#define	TRACKFLAG_HAS_SURROGATE   0x00000004
#define	TRACKFLAG_PROTECTEDIRP   0x00000008
#define	TRACKFLAG_QUEUED_INTERNALLY   0x00000010
#define	TRACKFLAG_BOGUS   0x00000020
#define	TRACKFLAG_RELEASED   0x00000040
#define	TRACKFLAG_SRB_MUNGED   0x00000080
#define	TRACKFLAG_SWAPPED_BACK   0x00000100
#define	TRACKFLAG_WATERMARKED   0x00100000
#define	TRACKFLAG_IO_ALLOCATED   0x00200000
#define	TRACKFLAG_UNWOUND_BADLY   0x00400000
#define	TRACKFLAG_PASSED_FAILURE   0x01000000
#define	TRACKFLAG_PASSED_AT_BAD_IRQL   0x02000000
#define	TRACKFLAG_IN_TRANSIT   0x40000000
#define	TRACKFLAG_REMOVED_FROM_TABLE   0x80000000
#define	DOE_DESIGNATED_FDO   0x80000000
#define	DOE_BOTTOM_OF_FDO_STACK   0x40000000
#define	DOE_RAW_FDO   0x20000000
#define	DOE_EXAMINED   0x10000000
#define	DOE_TRACKED   0x08000000
#define	STACKFLAG_NO_HANDLER   0x80000000
#define	STACKFLAG_REQUEST_COMPLETED   0x40000000
#define	STACKFLAG_CHECK_FOR_REFERENCE   0x20000000
#define	STACKFLAG_REACHED_PDO   0x10000000
#define	STACKFLAG_FIRST_REQUEST   0x08000000
#define	CALLFLAG_COMPLETED   0x80000000
#define	CALLFLAG_IS_REMOVE_IRP   0x40000000
#define	CALLFLAG_REMOVING_FDO_STACK_DO   0x20000000
#define	CALLFLAG_OVERRIDE_STATUS   0x10000000
#define	CALLFLAG_TOPMOST_IN_SLOT   0x08000000
#define	ALLOCFLAG_PROTECTEDIRP   0x00000001
#define	SESSIONFLAG_UNWOUND_INCONSISTANT   0x00000001
#define	IRP_SYSTEM_RESTRICTED   0x00000001
#define	IRP_BOGUS   0x00000002
#define	SL_NOTCOPIED   0x10
#define	IRP_ALLOCATION_MONITORED   0x80
#define	STARTED_TOP_OF_STACK   1
#define	FORWARDED_TO_NEXT_DO   2
#define	SKIPPED_A_DO   3
#define	STARTED_INSIDE_STACK   4
#define	CHANGED_STACKS_AT_BOTTOM   5
#define	CHANGED_STACKS_MID_STACK   6
#define	IRP_ALLOC_COUNT   5
#define	SPECIALIRP_MARK_NON_TRACKABLE(Irp)
#define	SPECIALIRP_IOF_CALL_1(pIrp, DeviceObject, st1)
#define	SPECIALIRP_IOF_CALL_2(Irp, DeviceObject, Routine, FinalStatus, st1)
#define	SPECIALIRP_IOF_COMPLETE_1(Irp, PriorityBoost, CompletionPacket)
#define	SPECIALIRP_IOF_COMPLETE_2(Irp, CompletionPacket)
#define	SPECIALIRP_IOF_COMPLETE_3(Irp, Routine, CompletionPacket)
#define	SPECIALIRP_IOF_COMPLETE_4(Irp, ReturnedStatus, CompletionPacket)
#define	SPECIALIRP_IOF_COMPLETE_5(Irp, CompletionPacket)
#define	SPECIALIRP_IO_CANCEL_IRP(Irp, CancelHandled, ReturnValue)
#define	IOP_DIAG_THROW_CHAFF_AT_STARTED_PDO_STACK(DeviceObject)
#define	SPECIALIRP_IO_FREE_IRP(Irp, FreeHandled)
#define	SPECIALIRP_IO_ALLOCATE_IRP_1(StackSize, Quota, IrpPointer)
#define	SPECIALIRP_IO_ALLOCATE_IRP_2(Irp)
#define	SPECIALIRP_IO_INITIALIZE_IRP(Irp, PacketSize, StackSize, InitHandled)
#define	SPECIALIRP_IO_DELETE_DEVICE(Device)
#define	SPECIALIRP_IO_ATTACH_DEVICE_TO_DEVICE_STACK(NewDevice, ExistingDevice)
#define	SPECIALIRP_IO_DETACH_DEVICE(TargetDevice)
#define	SPECIALIRP_WATERMARK_IRP(Irp, Flags)
#define	SPECIALIRP_IOP_COMPLETE_REQUEST(Irp, StackPointer)
#define	TRACKIRP_DBGPRINT(txt, level)
Typedefs
typedef _IOFCALLDRIVER_STACKDATA *	PIOFCALLDRIVER_STACKDATA
typedef _IOV_STACK_LOCATION *	PIOV_STACK_LOCATION
typedef _IOV_REQUEST_PACKET *	PIOV_REQUEST_PACKET
typedef _IOV_SESSION_DATA *	PIOV_SESSION_DATA
typedef _IOFCALLDRIVER_STACKDATA	IOFCALLDRIVER_STACKDATA
typedef _IOV_STACK_LOCATION	IOV_STACK_LOCATION
typedef _IOV_SESSION_DATA	IOV_SESSION_DATA
typedef _IOV_REQUEST_PACKET	IOV_REQUEST_PACKET
typedef _DEFERRAL_CONTEXT	DEFERRAL_CONTEXT
typedef _DEFERRAL_CONTEXT *	PDEFERRAL_CONTEXT
typedef _IOFCOMPLETEREQUEST_STACKDATA	IOFCOMPLETEREQUEST_STACKDATA
typedef _IOFCOMPLETEREQUEST_STACKDATA *	PIOFCOMPLETEREQUEST_STACKDATA
Enumerations
enum	DEFER_ACTION { DEFERACTION_QUEUE_WORKITEM, DEFERACTION_QUEUE_PASSIVE_TIMER, DEFERACTION_QUEUE_DISPATCH_TIMER, DEFERACTION_NORMAL }
Functions
BOOLEAN FASTCALL	IovpInitIrpTracking (IN ULONG Level, IN ULONG Flags)
VOID FASTCALL	IovpCallDriver1 (IN OUT PIRP *IrpPointer, IN PDEVICE_OBJECT DeviceObject, IN OUT PIOFCALLDRIVER_STACKDATA IofCallDriverStackData)
VOID FASTCALL	IovpCallDriver2 (IN PIRP Irp, IN PDEVICE_OBJECT DeviceObject, IN PVOID Routine, IN OUT NTSTATUS *FinalStatus, IN PIOFCALLDRIVER_STACKDATA IofCallDriverStackData)
VOID FASTCALL	IovpCompleteRequest1 (IN PIRP Irp, IN CCHAR PriorityBoost, IN OUT PIOFCOMPLETEREQUEST_STACKDATA CompletionPacket)
VOID FASTCALL	IovpCompleteRequest2 (IN PIRP Irp, IN OUT PIOFCOMPLETEREQUEST_STACKDATA CompletionPacket)
VOID FASTCALL	IovpCompleteRequest3 (IN PIRP Irp, IN PVOID Routine, IN OUT PIOFCOMPLETEREQUEST_STACKDATA CompletionPacket)
VOID FASTCALL	IovpCompleteRequest4 (IN PIRP Irp, IN NTSTATUS ReturnedStatus, IN OUT PIOFCOMPLETEREQUEST_STACKDATA CompletionPacket)
VOID FASTCALL	IovpCompleteRequest5 (IN PIRP Irp, IN OUT PIOFCOMPLETEREQUEST_STACKDATA CompletionPacket)
VOID FASTCALL	IovpCompleteRequestApc (IN PIRP Irp, IN PVOID BestStackOffset)
VOID FASTCALL	IovpCancelIrp (IN PIRP Irp, IN OUT PBOOLEAN CancelHandled, IN OUT PBOOLEAN ReturnValue)
VOID FASTCALL	IovpFreeIrp (IN PIRP Irp, IN OUT PBOOLEAN FreeHandled)
VOID FASTCALL	IovpAllocateIrp1 (IN CCHAR StackSize, IN BOOLEAN ChargeQuota, IN OUT PIRP *IrpPointer)
VOID FASTCALL	IovpAllocateIrp2 (IN PIRP Irp)
VOID FASTCALL	IovpInitializeIrp (IN OUT PIRP Irp, IN USHORT PacketSize, IN CCHAR StackSize, IN OUT PBOOLEAN InitializeHandled)
VOID	IovpExamineIrpStackForwarding (IN OUT PIOV_REQUEST_PACKET IovPacket, IN BOOLEAN IsNewSession, IN ULONG ForwardMethod, IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN OUT PIO_STACK_LOCATION *IoCurrentStackLocation, OUT PIO_STACK_LOCATION *IoLastStackLocation, OUT ULONG *StackLocationsAdvanced)
NTSTATUS	IovpSwapSurrogateIrp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
VOID FASTCALL	IovpExamineDevObjForwarding (IN PDEVICE_OBJECT DeviceBeingCalled, IN PDEVICE_OBJECT DeviceLastCalled, OUT PULONG ForwardingTechnique)
VOID FASTCALL	IovpFinalizeIrpSettings (IN OUT PIOV_REQUEST_PACKET IrpTrackingData, IN BOOLEAN SurrogateIrpSwapped)
PDEVICE_OBJECT FASTCALL	IovpGetDeviceAttachedTo (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS	IovpInternalCompletionTrap (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
NTSTATUS	IovpInternalDeferredCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
PDEVICE_OBJECT FASTCALL	IovpGetLowestDevice (IN PDEVICE_OBJECT DeviceObject)
VOID FASTCALL	IovpAssertNonLegacyDevice (IN PDEVICE_OBJECT DeviceObject, IN ULONG StackFramesToSkip, IN PUCHAR FailureTxt)
BOOLEAN FASTCALL	IovpIsInFdoStack (IN PDEVICE_OBJECT DeviceObject)
BOOLEAN FASTCALL	IovpDoAssertIrps (VOID)
VOID FASTCALL	IovpSeedStack (VOID)
VOID FASTCALL	IovpSeedOnePage (VOID)
VOID FASTCALL	IovpSeedTwoPages (VOID)
VOID FASTCALL	IovpSeedThreePages (VOID)
VOID	IovpInternalCompleteAfterWait (IN PVOID Context)
VOID	IovpInternalCompleteAtDPC (IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
VOID	IovpAttachDeviceToDeviceStack (IN PDEVICE_OBJECT NewDevice, IN PDEVICE_OBJECT ExistingDevice)
VOID	IovpDetachDevice (IN PDEVICE_OBJECT LowerDevice)
VOID	IovpDeleteDevice (IN PDEVICE_OBJECT Device)
BOOLEAN	IovpIsInterestingStack (IN PDEVICE_OBJECT DeviceObject)
BOOLEAN	IovpIsInterestingDriver (IN PDRIVER_OBJECT DriverObject)
VOID	IovpReexamineAllStacks (VOID)
BOOLEAN	IovpEnumDevObjCallback (IN PVOID Object, IN PUNICODE_STRING ObjectName, IN ULONG HandleCount, IN ULONG PointerCount, IN PVOID Context)
BOOLEAN	IovpAdvanceStackDownwards (IN PIOV_STACK_LOCATION StackDataArray, IN CCHAR CurrentLocation, IN PIO_STACK_LOCATION IrpSp, IN PIO_STACK_LOCATION IrpLastSp OPTIONAL, IN ULONG LocationsAdvanced, IN BOOLEAN IsNewRequest, IN BOOLEAN MarkAsTaken, OUT PIOV_STACK_LOCATION *StackLocationInfo)
Variables
ULONG	IovpHackFlags
ULONG	IovpTrackingFlags

---

Define Documentation

#define ALLOCFLAG_PROTECTEDIRP   0x00000001

Definition at line 106 of file trackirp.h.

#define ASSERTFLAG_COMPLETEATDPC   0x00000100

Definition at line 35 of file trackirp.h. Referenced by IovpCompleteRequest2(), IovpCompleteRequest5(), IovpInitIrpTracking(), and IovpInternalDeferredCompletion().

#define ASSERTFLAG_COMPLETEATPASSIVE   0x00000200

Definition at line 36 of file trackirp.h. Referenced by IovpCompleteRequest3(), IovpInternalDeferredCompletion(), and IovpSessionDataCreate().

#define ASSERTFLAG_CONSUME_ALWAYS   0x00000040

Definition at line 33 of file trackirp.h. Referenced by IovpExamineIrpStackForwarding(), and IovpInitIrpTracking().

#define ASSERTFLAG_DEFERCOMPLETION   0x00000800

Definition at line 37 of file trackirp.h. Referenced by IovpCompleteRequest3(), IovpInitIrpTracking(), IovpInternalDeferredCompletion(), and IovpSessionDataCreate().

#define ASSERTFLAG_FORCEPENDING   0x00000080

Definition at line 34 of file trackirp.h. Referenced by IovpCallDriver2(), IovpCompleteRequest1(), IovpCompleteRequest3(), IovpCompleteRequest4(), IovpInitIrpTracking(), IovpInternalDeferredCompletion(), and IovpSessionDataCreate().

#define ASSERTFLAG_MONITOR_ALLOCS   0x00000002

Definition at line 28 of file trackirp.h. Referenced by IovpAllocateIrp1(), IovpAllocateIrp2(), and IovpInitIrpTracking().

#define ASSERTFLAG_MONITORMAJORS   0x00000008

Definition at line 30 of file trackirp.h. Referenced by IovpCallDriver1(), IovpCompleteRequest2(), and IovpInitIrpTracking().

#define ASSERTFLAG_POLICEIRPS   0x00000004

Definition at line 29 of file trackirp.h. Referenced by IovpAllocateIrp1(), IovpCallDriver1(), IovpCallDriver2(), IovpCancelIrp(), IovpCompleteRequest2(), IovpCompleteRequest3(), IovpExamineIrpStackForwarding(), IovpFreeIrp(), IovpInitializeIrp(), IovpInitIrpTracking(), IovpInternalDeferredCompletion(), IovpSessionDataDeterminePolicy(), and IovpSwapSurrogateIrp().

#define ASSERTFLAG_ROTATE_STATUS   0x00001000

Definition at line 38 of file trackirp.h. Referenced by IovpCompleteRequest2(), and IovpInitIrpTracking().

#define ASSERTFLAG_SEEDSTACK   0x00010000

Definition at line 41 of file trackirp.h. Referenced by IovpInitIrpTracking(), and IovpSeedStack().

#define ASSERTFLAG_SMASH_SRBS   0x00000020

Definition at line 32 of file trackirp.h. Referenced by IovpInitIrpTracking(), and IovpSessionDataDeterminePolicy().

#define ASSERTFLAG_SURROGATE   0x00000010

Definition at line 31 of file trackirp.h. Referenced by IovpInitIrpTracking(), and IovpSessionDataDeterminePolicy().

#define ASSERTFLAG_TRACKIRPS   0x00000001

Definition at line 27 of file trackirp.h. Referenced by IovpCallDriver1(), IovpInitIrpTracking(), and IovpSessionDataDeterminePolicy().

#define ASSERTMASK_COMPLETESTYLE   0x00000F80

Definition at line 40 of file trackirp.h.

#define CALLFLAG_COMPLETED   0x80000000

Definition at line 100 of file trackirp.h. Referenced by IovpCallDriver2(), and IovpCompleteRequest2().

#define CALLFLAG_IS_REMOVE_IRP   0x40000000

Definition at line 101 of file trackirp.h. Referenced by IovpCallDriver1(), and IovpCallDriver2().

#define CALLFLAG_OVERRIDE_STATUS   0x10000000

Definition at line 103 of file trackirp.h. Referenced by IovpCallDriver2(), and IovpCompleteRequest2().

#define CALLFLAG_REMOVING_FDO_STACK_DO   0x20000000

Definition at line 102 of file trackirp.h. Referenced by IovpCallDriver1(), and IovpCallDriver2().

#define CALLFLAG_TOPMOST_IN_SLOT   0x08000000

Definition at line 104 of file trackirp.h. Referenced by IovpCallDriver1().

#define CHANGED_STACKS_AT_BOTTOM   5

Definition at line 121 of file trackirp.h. Referenced by IovpAssertIrpStackDownward(), and IovpExamineDevObjForwarding().

#define CHANGED_STACKS_MID_STACK   6

Definition at line 122 of file trackirp.h. Referenced by IovpAssertIrpStackDownward(), and IovpExamineDevObjForwarding().

#define DOE_BOTTOM_OF_FDO_STACK   0x40000000

Definition at line 89 of file trackirp.h. Referenced by IopCallDriverAddDevice(), and IovpIsInFdoStack().

#define DOE_DESIGNATED_FDO   0x80000000

Definition at line 88 of file trackirp.h. Referenced by IopCallDriverAddDevice(), and IovpAssertIrpStackDownward().

#define DOE_EXAMINED   0x10000000

Definition at line 91 of file trackirp.h. Referenced by IovpDetachDevice(), IovpEnumDevObjCallback(), and IovpIsInterestingStack().

#define DOE_RAW_FDO   0x20000000

Definition at line 90 of file trackirp.h. Referenced by IopCallDriverAddDevice(), IovpAssertIrpStackDownward(), and IovpCallDriver1().

#define DOE_TRACKED   0x08000000

Definition at line 92 of file trackirp.h. Referenced by IovpDetachDevice(), IovpEnumDevObjCallback(), and IovpIsInterestingStack().

#define FORWARDED_TO_NEXT_DO   2

Definition at line 118 of file trackirp.h. Referenced by IovpAssertIrpStackDownward(), IovpExamineDevObjForwarding(), and IovpExamineIrpStackForwarding().

#define HACKFLAG_FOR_ACPI   0x00000004

Definition at line 52 of file trackirp.h. Referenced by IovpInitIrpTracking(), and IovpThrowChaffAtStartedPdoStack().

#define HACKFLAG_FOR_BOGUSIRPS   0x00000008

Definition at line 53 of file trackirp.h. Referenced by IovpInitIrpTracking(), and IovpThrowChaffAtStartedPdoStack().

#define HACKFLAG_FOR_MUP   0x00000001

Definition at line 50 of file trackirp.h. Referenced by IovpInitIrpTracking(), and IovpSessionDataDeterminePolicy().

#define HACKFLAG_FOR_SCSIPORT   0x00000002

Definition at line 51 of file trackirp.h. Referenced by IovpExamineIrpStackForwarding(), and IovpInitIrpTracking().

#define HACKHACKS_ENABLED

Definition at line 49 of file trackirp.h.

#define IOP_DIAG_THROW_CHAFF_AT_STARTED_PDO_STACK (  DeviceObject   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpThrowChaffAtStartedPdoStack(DeviceObject);\ }\ } Definition at line 628 of file trackirp.h. Referenced by IopEnumerateDevice().

#define IRP_ALLOC_COUNT   5

Definition at line 124 of file trackirp.h. Referenced by IovpAllocateIrp1(), and IovpAllocateIrp2().

#define IRP_ALLOCATION_MONITORED   0x80

Definition at line 115 of file trackirp.h. Referenced by IovpAllocateIrp1(), IovpAllocateIrp2(), and IovpFreeIrp().

#define IRP_BOGUS   0x00000002

Definition at line 111 of file trackirp.h. Referenced by IovpThrowBogusSynchronousIrp(), and IovpWatermarkIrp().

#define IRP_DIAG_HAS_SURROGATE   0x02000000

Definition at line 66 of file trackirp.h. Referenced by IovpCompleteRequest1(), IovpSessionDataAttachSurrogate(), and IovpSessionDataFinalizeSurrogate().

#define IRP_DIAG_IS_SURROGATE   0x01000000

Definition at line 67 of file trackirp.h. Referenced by IovpSessionDataAttachSurrogate(), and IovpSessionDataFinalizeSurrogate().

#define IRP_SYSTEM_RESTRICTED   0x00000001

Definition at line 110 of file trackirp.h. Referenced by IopAsynchronousCall(), IopEjectDevice(), IopFilterResourceRequirementsCall(), IopSynchronousCall(), and IovpWatermarkIrp().

#define IRPFLAG_EXAMINE_MASK   0xC0000000

Definition at line 61 of file trackirp.h. Referenced by IovpCallDriver1(), and IovpSessionDataFinalizeSurrogate().

#define IRPFLAG_EXAMINE_NOT_TRACKED   0x80000000

Definition at line 62 of file trackirp.h. Referenced by IovpCallDriver1().

#define IRPFLAG_EXAMINE_TRACKED   0x40000000

Definition at line 63 of file trackirp.h. Referenced by IovpAllocateIrp1(), IovpAllocateIrp2(), and IovpCallDriver1().

#define IRPFLAG_EXAMINE_UNMARKED   0x00000000

Definition at line 64 of file trackirp.h. Referenced by IovpCallDriver1().

#define SESSIONFLAG_UNWOUND_INCONSISTANT   0x00000001

Definition at line 108 of file trackirp.h. Referenced by IovpCallDriver2().

#define SKIPPED_A_DO   3

Definition at line 119 of file trackirp.h. Referenced by IovpAssertIrpStackDownward(), and IovpExamineDevObjForwarding().

#define SL_NOTCOPIED   0x10

Definition at line 113 of file trackirp.h. Referenced by IovpCallDriver1(), IovpExamineIrpStackForwarding(), and IovSpecialIrpCompleteRequest().

#define SPECIALIRP_IO_ALLOCATE_IRP_1 (  StackSize, Quota, IrpPointer   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpAllocateIrp1((StackSize), (Quota), (IrpPointer));\ } else { \ *(IrpPointer) = NULL ; \ } \ } Definition at line 644 of file trackirp.h. Referenced by IovAllocateIrp().

#define SPECIALIRP_IO_ALLOCATE_IRP_2 (  Irp   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpAllocateIrp2(Irp);\ }\ } Definition at line 653 of file trackirp.h. Referenced by IovAllocateIrp().

#define SPECIALIRP_IO_ATTACH_DEVICE_TO_DEVICE_STACK (  NewDevice, ExistingDevice   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpAttachDeviceToDeviceStack(NewDevice, ExistingDevice);\ }\ } Definition at line 676 of file trackirp.h. Referenced by IovAttachDeviceToDeviceStack().

#define SPECIALIRP_IO_CANCEL_IRP (  Irp, CancelHandled, ReturnValue   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpCancelIrp((Irp), (CancelHandled), (ReturnValue));\ } else { \ *(CancelHandled) = FALSE ; \ } \ } Definition at line 619 of file trackirp.h. Referenced by IovCancelIrp().

#define SPECIALIRP_IO_DELETE_DEVICE (  Device   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpDeleteDevice(Device);\ }\ } Definition at line 669 of file trackirp.h. Referenced by IovDeleteDevice().

#define SPECIALIRP_IO_DETACH_DEVICE (  TargetDevice   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpDetachDevice(TargetDevice);\ }\ } Definition at line 683 of file trackirp.h. Referenced by IovDetachDevice().

#define SPECIALIRP_IO_FREE_IRP (  Irp, FreeHandled   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpFreeIrp((Irp), (FreeHandled));\ } else { \ *(FreeHandled) = FALSE ; \ } \ } Definition at line 635 of file trackirp.h. Referenced by IovFreeIrpPrivate().

#define SPECIALIRP_IO_INITIALIZE_IRP (  Irp, PacketSize, StackSize, InitHandled   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpInitializeIrp((Irp), (PacketSize), (StackSize), (InitHandled));\ } else { \ *(InitHandled) = FALSE ; \ }\ } Definition at line 660 of file trackirp.h. Referenced by IovInitializeIrp().

#define SPECIALIRP_IOF_CALL_1 (  pIrp, DeviceObject, st1   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpCallDriver1((pIrp), (DeviceObject), (st1));\ IovpSeedStack() ; \ } else { \ (st1)->IovSessionData = NULL ; \ SPECIALIRP_MARK_NON_TRACKABLE(*pIrp); \ } \ } Definition at line 564 of file trackirp.h. Referenced by IovSpecialIrpCallDriver().

#define SPECIALIRP_IOF_CALL_2 (  Irp, DeviceObject, Routine, FinalStatus, st1   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpCallDriver2((Irp), (DeviceObject), (Routine), (FinalStatus), (st1));\ } \ } Definition at line 575 of file trackirp.h. Referenced by IovSpecialIrpCallDriver().

#define SPECIALIRP_IOF_COMPLETE_1 (  Irp, PriorityBoost, CompletionPacket   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpCompleteRequest1((Irp), (PriorityBoost), (CompletionPacket));\ } else { \ (CompletionPacket)->IovSessionData = NULL ; \ } \ } Definition at line 582 of file trackirp.h.

#define SPECIALIRP_IOF_COMPLETE_2 (  Irp, CompletionPacket   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpCompleteRequest2((Irp), (CompletionPacket));\ } \ } Definition at line 591 of file trackirp.h.

#define SPECIALIRP_IOF_COMPLETE_3 (  Irp, Routine, CompletionPacket   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpCompleteRequest3((Irp), (Routine), (CompletionPacket));\ } \ } Definition at line 598 of file trackirp.h.

#define SPECIALIRP_IOF_COMPLETE_4 (  Irp, ReturnedStatus, CompletionPacket   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpCompleteRequest4((Irp), (ReturnedStatus), (CompletionPacket));\ } \ } Definition at line 605 of file trackirp.h.

#define SPECIALIRP_IOF_COMPLETE_5 (  Irp, CompletionPacket   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpCompleteRequest5((Irp), (CompletionPacket));\ } \ } Definition at line 612 of file trackirp.h.

#define SPECIALIRP_IOP_COMPLETE_REQUEST (  Irp, StackPointer   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpCompleteRequestApc(Irp, StackPointer);\ }\ } Definition at line 697 of file trackirp.h.

#define SPECIALIRP_MARK_NON_TRACKABLE (  Irp   )

Value: { \ (Irp)->Flags |= IRPFLAG_EXAMINE_NOT_TRACKED; \ } Definition at line 560 of file trackirp.h.

#define SPECIALIRP_WATERMARK_IRP (  Irp, Flags   )

Value: {\ if (IovpTrackingFlags && IovpDoAssertIrps()) { \ IovpWatermarkIrp(Irp, Flags);\ }\ } Definition at line 690 of file trackirp.h. Referenced by IopAsynchronousCall(), IopEjectDevice(), IopFilterResourceRequirementsCall(), IopSynchronousCall(), and IovpThrowBogusSynchronousIrp().

#define STACKFLAG_CHECK_FOR_REFERENCE   0x20000000

Definition at line 96 of file trackirp.h. Referenced by IovpAssertIrpStackUpward(), and IovpAssertNewRequest().

#define STACKFLAG_FIRST_REQUEST   0x08000000

Definition at line 98 of file trackirp.h. Referenced by IovpAssertIrpStackDownward(), IovpAssertNewRequest(), and IovpCallDriver1().

#define STACKFLAG_NO_HANDLER   0x80000000

Definition at line 94 of file trackirp.h. Referenced by IovpAssertIrpStackDownward(), and IovpAssertIrpStackUpward().

#define STACKFLAG_REACHED_PDO   0x10000000

Definition at line 97 of file trackirp.h. Referenced by IovpAssertIrpStackUpward(), and IovpCallDriver1().

#define STACKFLAG_REQUEST_COMPLETED   0x40000000

Definition at line 95 of file trackirp.h. Referenced by IovpCompleteRequest2().

#define STARTED_INSIDE_STACK   4

Definition at line 120 of file trackirp.h. Referenced by IovpAssertIrpStackDownward(), and IovpExamineDevObjForwarding().

#define STARTED_TOP_OF_STACK   1

Definition at line 117 of file trackirp.h. Referenced by IovpAssertIrpStackDownward(), and IovpExamineDevObjForwarding().

#define TRACKFLAG_ACTIVE   0x00000001

Definition at line 70 of file trackirp.h. Referenced by IovpCallDriver1(), IovpCancelIrp(), IovpSessionDataAttachSurrogate(), IovpSessionDataCreate(), and IovpTrackingDataGetCurrentSessionData().

#define TRACKFLAG_BOGUS   0x00000020

Definition at line 76 of file trackirp.h. Referenced by IovpAssertIrpStackDownward(), IovpAssertIrpStackUpward(), and IovpWatermarkIrp().

#define TRACKFLAG_HAS_SURROGATE   0x00000004

Definition at line 72 of file trackirp.h. Referenced by IovpCancelIrp(), and IovpSessionDataAttachSurrogate().

#define TRACKFLAG_IN_TRANSIT   0x40000000

Definition at line 85 of file trackirp.h.

#define TRACKFLAG_IO_ALLOCATED   0x00200000

Definition at line 81 of file trackirp.h. Referenced by IovpAllocateIrp1(), IovpAllocateIrp2(), IovpAssertNewRequest(), IovpFreeIrp(), and IovpInitializeIrp().

#define TRACKFLAG_PASSED_AT_BAD_IRQL   0x02000000

Definition at line 84 of file trackirp.h. Referenced by IovpAssertIrpStackDownward().

#define TRACKFLAG_PASSED_FAILURE   0x01000000

Definition at line 83 of file trackirp.h. Referenced by IovpAssertIrpStackDownward(), IovpAssertNewRequest(), and IovpSessionDataCreate().

#define TRACKFLAG_PROTECTEDIRP   0x00000008

Definition at line 73 of file trackirp.h. Referenced by IovpAllocateIrp1(), and IovpFreeIrp().

#define TRACKFLAG_QUEUED_INTERNALLY   0x00000010

Definition at line 75 of file trackirp.h. Referenced by IovpCallDriver1(), IovpCancelIrp(), IovpCompleteRequest1(), IovpInternalCompleteAfterWait(), IovpInternalDeferredCompletion(), and IovpSessionDataCreate().

#define TRACKFLAG_RELEASED   0x00000040

Definition at line 77 of file trackirp.h. Referenced by IovpSessionDataCreate().

#define TRACKFLAG_REMOVED_FROM_TABLE   0x80000000

Definition at line 86 of file trackirp.h. Referenced by IovpTrackingDataFree().

#define TRACKFLAG_SRB_MUNGED   0x00000080

Definition at line 78 of file trackirp.h. Referenced by IovpSessionDataAttachSurrogate(), and IovpSessionDataCreate().

#define TRACKFLAG_SURROGATE   0x00000002

Definition at line 71 of file trackirp.h. Referenced by IovpCompleteRequest2(), IovpSessionDataAttachSurrogate(), and IovpSessionDataFinalizeSurrogate().

#define TRACKFLAG_SWAPPED_BACK   0x00000100

Definition at line 79 of file trackirp.h. Referenced by IovpSessionDataCreate(), and IovpSwapSurrogateIrp().

#define TRACKFLAG_UNWOUND_BADLY   0x00400000

Definition at line 82 of file trackirp.h. Referenced by IovpCallDriver2(), and IovpFreeIrp().

#define TRACKFLAG_WATERMARKED   0x00100000

Definition at line 80 of file trackirp.h. Referenced by IovpAssertNewRequest(), and IovpWatermarkIrp().

#define TRACKIRP_DBGPRINT (  txt, level   )

Definition at line 712 of file trackirp.h. Referenced by IovpAdvanceStackDownwards(), IovpCallDriver1(), IovpCallDriver2(), IovpCompleteRequest1(), IovpCompleteRequest2(), IovpSessionDataClose(), IovpSessionDataCreate(), IovpSessionDataDereference(), IovpSessionDataReference(), IovpSwapSurrogateIrp(), IovpTrackingDataCreateAndLock(), IovpTrackingDataDereference(), IovpTrackingDataFindAndLock(), IovpTrackingDataFree(), and IovpTrackingDataReference().

---

Typedef Documentation

typedef struct _DEFERRAL_CONTEXT DEFERRAL_CONTEXT

Referenced by IovpCompleteRequest3().

typedef struct _IOFCALLDRIVER_STACKDATA IOFCALLDRIVER_STACKDATA

Referenced by IovpCallDriver1(), and IovSpecialIrpCallDriver().

typedef struct _IOFCOMPLETEREQUEST_STACKDATA IOFCOMPLETEREQUEST_STACKDATA

typedef struct _IOV_REQUEST_PACKET IOV_REQUEST_PACKET

Referenced by IovpSessionDataAttachSurrogate(), and IovpTrackingDataCreateAndLock().

typedef struct _IOV_SESSION_DATA IOV_SESSION_DATA

Referenced by IovpSessionDataCreate().

typedef struct _IOV_STACK_LOCATION IOV_STACK_LOCATION

Referenced by IovpSessionDataCreate(), and IovpTrackingDataCreateAndLock().

typedef struct _DEFERRAL_CONTEXT * PDEFERRAL_CONTEXT

Referenced by IovpCompleteRequest3().

typedef struct _IOFCALLDRIVER_STACKDATA* PIOFCALLDRIVER_STACKDATA

Definition at line 139 of file trackirp.h. Referenced by IovpCallDriver1().

typedef struct _IOFCOMPLETEREQUEST_STACKDATA * PIOFCOMPLETEREQUEST_STACKDATA

Referenced by IovpCompleteRequest1().

typedef struct _IOV_REQUEST_PACKET* PIOV_REQUEST_PACKET

Definition at line 141 of file trackirp.h. Referenced by IovpAssertNewIrps(), and IovpSessionDataCreate().

typedef struct _IOV_SESSION_DATA* PIOV_SESSION_DATA

Definition at line 142 of file trackirp.h. Referenced by IovpAssertIrpStackDownward().

typedef struct _IOV_STACK_LOCATION* PIOV_STACK_LOCATION

Definition at line 140 of file trackirp.h. Referenced by IovpAssertNewIrps(), and IovpCallDriver1().

---

Enumeration Type Documentation

enum DEFER_ACTION

Enumeration values: DEFERACTION_QUEUE_WORKITEM  DEFERACTION_QUEUE_PASSIVE_TIMER  DEFERACTION_QUEUE_DISPATCH_TIMER  DEFERACTION_NORMAL  Definition at line 126 of file trackirp.h. Referenced by IovpInternalDeferredCompletion(). { DEFERACTION_QUEUE_WORKITEM, DEFERACTION_QUEUE_PASSIVE_TIMER, DEFERACTION_QUEUE_DISPATCH_TIMER, DEFERACTION_NORMAL } DEFER_ACTION;

---

Function Documentation

BOOLEAN IovpAdvanceStackDownwards (  IN PIOV_STACK_LOCATION  StackDataArray, IN CCHAR  CurrentLocation, IN PIO_STACK_LOCATION  IrpSp, IN PIO_STACK_LOCATION IrpLastSp  OPTIONAL, IN ULONG  LocationsAdvanced, IN BOOLEAN  IsNewRequest, IN BOOLEAN  MarkAsTaken, OUT PIOV_STACK_LOCATION *  StackLocationInfo )

Definition at line 2023 of file trackirp.c. References ASSERT, _IOV_STACK_LOCATION::CallStackData, _IOV_STACK_LOCATION::InUse, _IOV_STACK_LOCATION::IrpSp, _IOV_STACK_LOCATION::LastDispatch, NULL, _IOV_STACK_LOCATION::PerfDispatchStart, _IOV_STACK_LOCATION::PerfStackLocationStart, _IOV_STACK_LOCATION::RequestsFirstStackLocation, TRACKIRP_DBGPRINT, and TRUE. Referenced by IovpCallDriver1(), and IovpCompleteRequest1(). { PIOV_STACK_LOCATION iovCurrentStackLocation, advancedLocationData, requestOriginalSLD; PIO_STACK_LOCATION irpSpTemp; PLARGE_INTEGER dispatchTime, stackTime; BOOLEAN isNewSession, wasInUse; PVOID dispatchRoutine; isNewSession = (IrpLastSp == NULL); ASSERT((!isNewSession) || (LocationsAdvanced == 1)); ASSERT(isNewSession || ((ULONG) (IrpLastSp - IrpSp) == LocationsAdvanced)); // // The CurrentLocation will be decremented when we leave. If it hit's zero // we will bugcheck, therefore it should be at least two, and we'd need to // subtract two off it to make it an index into an array of slot locations // (our analog for stack locations). However we reserve an extra empty slot // at the head of the array to make our logic easier. Therefore we subtract // only one. // iovCurrentStackLocation = StackDataArray + CurrentLocation -1; TRACKIRP_DBGPRINT(( " Smacking %lx (%lx) to valid in SD\n", CurrentLocation -1, iovCurrentStackLocation ), 2); // // Note that we do set the InUse field. That's for the caller to do. // if (iovCurrentStackLocation->InUse) { // // The only way the stack slot could be in use is if we skipped before // ASSERT(!LocationsAdvanced); // && (!isNewSession) ASSERT(IrpSp == iovCurrentStackLocation->IrpSp); } else if (MarkAsTaken) { // // ADRIAO BUGBUG 01/02/1999 - // Is the below assertion is not true in the case of an internally // forwarded, completed, and then externally forwarded IRP? // ASSERT(LocationsAdvanced); // || isNewSession RtlZeroMemory(iovCurrentStackLocation, sizeof(IOV_STACK_LOCATION)); InitializeListHead(&iovCurrentStackLocation->CallStackData); iovCurrentStackLocation->IrpSp = IrpSp; } // // Determine the last original request. A "Request" is block of data in a // stack location that is progressively copied downwards as the IRP is // forwarded (ie, a forwarded START IRP, a forwarded IOCTL, etc). A clever // driver writer could use his own stack location to send down a quick // query before forwarding along the original request. We correctly // differentiate between those two unique requests within the IRP below. // if (isNewSession) { // // *We* are the original request. None of these fields below should // be used. // dispatchRoutine = NULL; requestOriginalSLD = NULL; stackTime = NULL; dispatchTime = NULL; } else if (LocationsAdvanced) { // // To get the original request (the pointer to the Irp slot that // represents where we *first* saw this request), we go backwards to get // the most recent previous irp slot data (set up when the device above // forwarded this Irp to us), and we read what it's original request was. // We also get the dispatch routine for that slot, which we will use to // backfill skipped slots if we advanced more than one Irp stack // location this time (ie, someone called IoSetNextIrpStackLocation). // dispatchTime = &iovCurrentStackLocation[LocationsAdvanced].PerfDispatchStart; stackTime = &iovCurrentStackLocation[LocationsAdvanced].PerfStackLocationStart; dispatchRoutine = iovCurrentStackLocation[LocationsAdvanced].LastDispatch; requestOriginalSLD = iovCurrentStackLocation[LocationsAdvanced].RequestsFirstStackLocation; ASSERT(dispatchRoutine); ASSERT(iovCurrentStackLocation[LocationsAdvanced].InUse); ASSERT(requestOriginalSLD->RequestsFirstStackLocation == requestOriginalSLD); iovCurrentStackLocation->RequestsFirstStackLocation = requestOriginalSLD; } else { // // We skipped. The slot should already be filled. // dispatchRoutine = NULL; dispatchTime = NULL; stackTime = NULL; requestOriginalSLD = iovCurrentStackLocation->RequestsFirstStackLocation; ASSERT(requestOriginalSLD); ASSERT(requestOriginalSLD->RequestsFirstStackLocation == requestOriginalSLD); } // // The previous request seen is in requestOriginalSLD (NULL if none). If // we advanced more than one stack location (ie, someone called // IoSetNextIrpStackLocation), we need to update the slots we never saw get // consumed. Note that the dispatch routine we set in the slot is for the // driver that owned the last slot - we do not use the device object at // that IrpSp because it might be stale (or perhaps even NULL). // advancedLocationData = iovCurrentStackLocation; irpSpTemp = IrpSp; while(LocationsAdvanced>1) { advancedLocationData++ ; LocationsAdvanced-- ; irpSpTemp++ ; TRACKIRP_DBGPRINT(( " Late smacking %lx to valid in CD1\n", advancedLocationData - StackDataArray ), 3) ; ASSERT(!advancedLocationData->InUse) ; RtlZeroMemory(advancedLocationData, sizeof(IOV_STACK_LOCATION)) ; InitializeListHead(&advancedLocationData->CallStackData) ; advancedLocationData->InUse = TRUE ; advancedLocationData->IrpSp = irpSpTemp ; advancedLocationData->RequestsFirstStackLocation = requestOriginalSLD ; advancedLocationData->PerfDispatchStart = *dispatchTime; advancedLocationData->PerfStackLocationStart = *stackTime; advancedLocationData->LastDispatch = dispatchRoutine ; } // // For the assertion below... // if (LocationsAdvanced) { irpSpTemp++ ; } ASSERT((irpSpTemp == IrpLastSp)||(IrpLastSp == NULL)) ; // // Write out the slot we're using. // *StackLocationInfo = iovCurrentStackLocation; if (!MarkAsTaken) { return iovCurrentStackLocation->InUse; } // // Record a pointer in this slot to the requests originating slot as // appropriate. // if (IsNewRequest) { TRACKIRP_DBGPRINT(( " CD1: %lx is a new request\n", advancedLocationData-StackDataArray ), 3) ; ASSERT(LocationsAdvanced == 1) ; // // ADRIAO BUGBUG 01/02/1999 - // // Why the **ll did I have this there? If this were correct then the // backfill logic above would need fixing. I think what I have now is // correct, not this: // // advancedLocationData->RequestsFirstStackLocation = advancedLocationData ; // iovCurrentStackLocation->RequestsFirstStackLocation = iovCurrentStackLocation; } else if (LocationsAdvanced) { ASSERT(!isNewSession) ; // // ADRIAO BUGBUG 01/02/1999 - // As per above, this should already have been handled. // //advancedLocationData->RequestsFirstStackLocation = requestOriginalSLD ; TRACKIRP_DBGPRINT(( " CD1: %lx is a request for %lx\n", advancedLocationData-StackDataArray, requestOriginalSLD-StackDataArray ), 3) ; } else { // // As we skipped, the request should not have changed. If it did, // either guy we called trashed the stack given to him (giving none // to the dude under him), or we incorrectly saw a new request when // we shouldn't have (see previous comment). // ASSERT(!isNewSession) ; ASSERT(advancedLocationData->RequestsFirstStackLocation == requestOriginalSLD) ; } wasInUse = iovCurrentStackLocation->InUse; iovCurrentStackLocation->InUse = TRUE; return wasInUse; }

VOID FASTCALL IovpAllocateIrp1 (  IN CCHAR  StackSize, IN BOOLEAN  ChargeQuota, IN OUT PIRP *  IrpPointer )

Definition at line 3132 of file trackirp.c. References _IOV_REQUEST_PACKET::AllocatorStack, ASSERTFLAG_MONITOR_ALLOCS, ASSERTFLAG_POLICEIRPS, _IOV_REQUEST_PACKET::Flags, IopInitializeIrp, IoSizeOfIrp, IovpProtectedIrpAllocate(), IovpTrackingDataCreateAndLock(), IovpTrackingDataReference(), IovpTrackingDataReleaseLock(), IovpTrackingFlags, IOVREFTYPE_POINTER, IRP_ALLOC_COUNT, IRP_ALLOCATION_MONITORED, IRPFLAG_EXAMINE_TRACKED, NULL, PsGetCurrentThread, RtlCaptureStackBackTrace(), TRACKFLAG_IO_ALLOCATED, and TRACKFLAG_PROTECTEDIRP. : This routine is called by IoAllocateIrp and returns an IRP iff we are handled the allocations ourselves. We may need to do this internally so we can turn off IRP lookaside lists and use the special pool to catch people reusing free'd IRPs. Arguments: StackSize - Count of stack locations to allocate for this IRP. ChargeQuote - TRUE if quote should be charged against the current thread. IrpPointer - Pointer to IRP if one was allocated. This will point to NULL after the call iff IoAllocateIrp should use it's normal lookaside list code. Return Value: None. --*/ { PIOV_REQUEST_PACKET iovPacket; PVOID returnAddress[1]; ULONG stackHash; PIRP irp; *IrpPointer = NULL ; if (!(IovpTrackingFlags&ASSERTFLAG_MONITOR_ALLOCS)) { return ; } if (!(IovpTrackingFlags&ASSERTFLAG_POLICEIRPS)) { return ; } irp = IovpProtectedIrpAllocate( StackSize, ChargeQuota, PsGetCurrentThread() ) ; if (irp == NULL) { return; } IopInitializeIrp(irp, IoSizeOfIrp(StackSize), StackSize); *IrpPointer = irp; iovPacket = IovpTrackingDataCreateAndLock(irp); if (iovPacket == NULL) { return; } IovpTrackingDataReference(iovPacket, IOVREFTYPE_POINTER); iovPacket->Flags |= TRACKFLAG_PROTECTEDIRP | TRACKFLAG_IO_ALLOCATED; irp->AllocationFlags |= IRP_ALLOCATION_MONITORED ; irp->Flags |= IRPFLAG_EXAMINE_TRACKED; // // Record he who allocated this IRP (if we can get it) // RtlCaptureStackBackTrace(3, IRP_ALLOC_COUNT, iovPacket->AllocatorStack, &stackHash) ; IovpTrackingDataReleaseLock(iovPacket) ; }

VOID FASTCALL IovpAllocateIrp2 (  IN PIRP  Irp  )

Definition at line 3216 of file trackirp.c. References _IRP::AllocationFlags, _IOV_REQUEST_PACKET::AllocatorStack, ASSERTFLAG_MONITOR_ALLOCS, _IRP::Flags, _IOV_REQUEST_PACKET::Flags, IovpTrackingDataCreateAndLock(), IovpTrackingDataReference(), IovpTrackingDataReleaseLock(), IovpTrackingFlags, IOVREFTYPE_POINTER, Irp, IRP_ALLOC_COUNT, IRP_ALLOCATION_MONITORED, IRPFLAG_EXAMINE_TRACKED, NULL, RtlCaptureStackBackTrace(), and TRACKFLAG_IO_ALLOCATED. : This routine is called by IoAllocateIrp and captures information if the IRP was allocated by the OS. Arguments: Irp - Pointer to IRP Return Value: None. --*/ { PIOV_REQUEST_PACKET iovPacket; PVOID returnAddress[1]; ULONG stackHash; if (!(IovpTrackingFlags&ASSERTFLAG_MONITOR_ALLOCS)) { return; } // ASSERT(!(IovpTrackingFlags&ASSERTFLAG_POLICEIRPS)); iovPacket = IovpTrackingDataCreateAndLock(Irp); if (iovPacket == NULL) { return; } IovpTrackingDataReference(iovPacket, IOVREFTYPE_POINTER); iovPacket->Flags |= TRACKFLAG_IO_ALLOCATED; Irp->AllocationFlags |= IRP_ALLOCATION_MONITORED; Irp->Flags |= IRPFLAG_EXAMINE_TRACKED; // // Record he who allocated this IRP (if we can get it) // RtlCaptureStackBackTrace(2, IRP_ALLOC_COUNT, iovPacket->AllocatorStack, &stackHash) ; IovpTrackingDataReleaseLock(iovPacket) ; }

VOID FASTCALL IovpAssertNonLegacyDevice (  IN PDEVICE_OBJECT  DeviceObject, IN ULONG  StackFramesToSkip, IN PUCHAR  FailureTxt )

Definition at line 3680 of file trackirp.c. References ASSERT, _DEVOBJ_EXTENSION::DeviceNode, _DEVICE_OBJECT::DeviceObjectExtension, DNF_LEGACY_DRIVER, _DEVICE_NODE::Flags, IovpGetLowestDevice(), and ObDereferenceObject. { PDEVICE_OBJECT pdoDeviceObject ; PDEVICE_NODE pDevNode ; pdoDeviceObject = IovpGetLowestDevice(DeviceObject) ; if (pdoDeviceObject) { pDevNode = pdoDeviceObject->DeviceObjectExtension->DeviceNode ; if (pDevNode&&(!(pDevNode->Flags&DNF_LEGACY_DRIVER))) { // // ADRIAO BUGBUG 12/30/98 - More stuff to fix... // ASSERT(0); /* WDM_FAIL_CALLER( (FailureTxt), StackFramesToSkip+1, NULL ); */ } ObDereferenceObject(pdoDeviceObject) ; } }

VOID IovpAttachDeviceToDeviceStack (  IN PDEVICE_OBJECT  NewDevice, IN PDEVICE_OBJECT  ExistingDevice )

Definition at line 3346 of file trackirp.c. { }

VOID FASTCALL IovpCallDriver1 (  IN OUT PIRP *  IrpPointer, IN PDEVICE_OBJECT  DeviceObject, IN OUT PIOFCALLDRIVER_STACKDATA  IofCallDriverStackData )

Definition at line 493 of file trackirp.c. References ASSERT, ASSERTFLAG_MONITORMAJORS, ASSERTFLAG_POLICEIRPS, ASSERTFLAG_TRACKIRPS, _IOV_REQUEST_PACKET::AssertFlags, CALLFLAG_IS_REMOVE_IRP, CALLFLAG_REMOVING_FDO_STACK_DO, CALLFLAG_TOPMOST_IN_SLOT, _IOV_STACK_LOCATION::CallStackData, _IRP::Cancel, _IRP::CancelRoutine, _IO_STACK_LOCATION::Control, _IRP::CurrentLocation, DCERROR_CANCELROUTINE_FORWARDED, DCERROR_NULL_DEVOBJ_FORWARDED, DCERROR_QUEUED_IRP_FORWARDED, DCPARAM_IRP, _IOV_SESSION_DATA::DeviceLastCalled, DOE_RAW_FDO, FAIL_CALLER_OF_IOFCALLDRIVER, FALSE, _IOV_STACK_LOCATION::Flags, _IOV_REQUEST_PACKET::Flags, _IRP::Flags, _IOV_SESSION_DATA::ForwardMethod, _IOV_STACK_LOCATION::InitialStatusBlock, IOFCALLDRIVER_STACKDATA, IoGetNextIrpStackLocation, IoSetNextIrpStackLocation, IoSkipCurrentIrpStackLocation, _IRP::IoStatus, IOVERIFIERINIT_RANDOMLY_CANCEL_IRPS, IovpAdvanceStackDownwards(), IovpAssertIrpStackDownward(), IovpAssertIsNewRequest(), IovpAssertNewIrps(), IovpAssertNewRequest(), IovpCancelCount, IovpExamineDevObjForwarding(), IovpExamineIrpStackForwarding(), IovpGetDeviceAttachedTo(), IovpGetLowestDevice(), IovpInitFlags, IovpIsInFdoStack(), IovpSessionDataAdvance(), IovpSessionDataCreate(), IovpSessionDataReference(), IovpTrackingDataCreateAndLock(), IovpTrackingDataFindAndLock(), IovpTrackingDataGetCurrentSessionData(), IovpTrackingDataReference(), IovpTrackingDataReleaseLock(), IovpTrackingFlags, IOVREFTYPE_POINTER, IRP_MJ_PNP, IRP_MN_REMOVE_DEVICE, IRP_PAGING_IO, IRPFLAG_EXAMINE_MASK, IRPFLAG_EXAMINE_NOT_TRACKED, IRPFLAG_EXAMINE_TRACKED, IRPFLAG_EXAMINE_UNMARKED, KeQuerySystemTime(), _IOV_STACK_LOCATION::LastDispatch, _IOV_REQUEST_PACKET::LastLocation, _IOV_STACK_LOCATION::LastStatusBlock, _IO_STACK_LOCATION::MajorFunction, _DRIVER_OBJECT::MajorFunction, _IO_STACK_LOCATION::MinorFunction, NULL, ObDereferenceObject, _IOV_STACK_LOCATION::PerfDispatchStart, _IOV_STACK_LOCATION::PerfStackLocationStart, PIOFCALLDRIVER_STACKDATA, PIOV_STACK_LOCATION, PsGetCurrentThread, _IOV_STACK_LOCATION::RequestsFirstStackLocation, SL_NOTCOPIED, _IOV_SESSION_DATA::StackData, STACKFLAG_FIRST_REQUEST, STACKFLAG_REACHED_PDO, _IOV_STACK_LOCATION::ThreadDispatchedTo, _IOV_REQUEST_PACKET::TrackedIrp, TRACKFLAG_ACTIVE, TRACKFLAG_QUEUED_INTERNALLY, TRACKIRP_DBGPRINT, and TRUE. : This routine is called by IofCallDriver just before adjusting the IRP stack and calling the driver's dispatch routine. Arguments: IrpPointer - a pointer* to the IRP passed in to IofCallDriver. This routine may change the pointer if a surrogate IRP is allocated. DeviceObject - Device object passed into IofCallDriver. IofCallDriverStackData - Pointer to a local variable on IofCallDriver's stack to store data. The stored information will be picked up by IovpCallDriver2, and may be adjusted at other times. Return Value: None. --*/ { PIOV_REQUEST_PACKET iovPacket; PIOV_SESSION_DATA iovSessionData; PIOV_STACK_LOCATION iovCurrentStackLocation; PIRP irp, replacementIrp; PIO_STACK_LOCATION irpSp, irpLastSp; BOOLEAN isNewSession, isNewRequest, previouslyInUse, surrogateSpawned; ULONG isSameStack; ULONG locationsAdvanced, completeStyle; PDEVICE_OBJECT pdo, lowerDeviceObject; PDRIVER_OBJECT driverObject; PVOID dispatchRoutine; irp = *IrpPointer; irpSp = IoGetNextIrpStackLocation( irp ); // // Preinitialize the CallStackData. // RtlZeroMemory(IofCallDriverStackData, sizeof(IOFCALLDRIVER_STACKDATA)); // // If we are going to die shortly, kindly say so. // if (DeviceObject == NULL) { FAIL_CALLER_OF_IOFCALLDRIVER( (DCERROR_NULL_DEVOBJ_FORWARDED, DCPARAM_IRP, irp), irpSp ); } // // The examined flag is set on any IRP that has come through // IofCallDriver. We use the flag to detect whether we have seen the IRP // before. // switch(irp->Flags&IRPFLAG_EXAMINE_MASK) { case IRPFLAG_EXAMINE_NOT_TRACKED: // // This packet is marked do not touch. So we ignore it. // iovPacket = NULL; break; case IRPFLAG_EXAMINE_TRACKED: // // This packet has been marked. We should find it. // iovPacket = IovpTrackingDataFindAndLock(irp); ASSERT(iovPacket != NULL); break; case IRPFLAG_EXAMINE_UNMARKED: iovPacket = IovpTrackingDataFindAndLock(irp); if (iovPacket) { // // Was tracked but cache flag got wiped. Replace. // irp->Flags |= IRPFLAG_EXAMINE_TRACKED; } else if (IovpTrackingFlags&ASSERTFLAG_TRACKIRPS) { // // Create the packet // iovPacket = IovpTrackingDataCreateAndLock(irp); if (iovPacket) { // // Mark it // irp->Flags |= IRPFLAG_EXAMINE_TRACKED; } else { // // No memory, try to keep it out of the IRP assert though. // irp->Flags |= IRPFLAG_EXAMINE_NOT_TRACKED; } } else { // // Do as told, don't track through IofCallDriver. // irp->Flags |= IRPFLAG_EXAMINE_NOT_TRACKED; } break; default: ASSERT(0); break; } if (iovPacket == NULL) { // // Nothing to track, get out. // return; } // // Find the current session. The session terminates when the final top-level // completion routine gets called. // iovSessionData = IovpTrackingDataGetCurrentSessionData(iovPacket); if (iovSessionData) { ASSERT(iovPacket->Flags&TRACKFLAG_ACTIVE); isNewSession = FALSE; IovpSessionDataAdvance( DeviceObject, iovSessionData, // This param is optional. &iovPacket, &surrogateSpawned ); } else if (!(iovPacket->Flags&TRACKFLAG_ACTIVE)){ iovPacket->Flags |= TRACKFLAG_ACTIVE; isNewSession = TRUE; iovSessionData = IovpSessionDataCreate( DeviceObject, &iovPacket, &surrogateSpawned ); } else { // // Might hit this path under low memory, or we are tracking allocations // but not the IRP sessions themselves. // } // // Let IovpCallDriver2 know what it's tracking... // IofCallDriverStackData->IovSessionData = iovSessionData; if (iovSessionData == NULL) { IovpTrackingDataReleaseLock(iovPacket) ; return; } if (surrogateSpawned) { // // iovPacket was changed to cover the surrogate IRP. Update our own // local variable and IofCallDriver's local variable appropriately. // irp = iovPacket->TrackedIrp; irpSp = IoGetNextIrpStackLocation(irp); *IrpPointer = irp; } if (isNewSession) { IovpTrackingDataReference(iovPacket, IOVREFTYPE_POINTER); IovpSessionDataReference(iovSessionData); } if (iovPacket->AssertFlags&ASSERTFLAG_POLICEIRPS) { // // If someone has given us an IRP with a cancel routine, beat them. Drivers // set cancel routines when they are going to be pending IRPs *themselves* // and should remove them before passing the IRP below. This is also true // as the driver will *not* call your cancel routine if he writes in his // own (which it may). Nor is the lower driver expected to put yours back // either... // if (irp->CancelRoutine) { FAIL_CALLER_OF_IOFCALLDRIVER( (DCERROR_CANCELROUTINE_FORWARDED, DCPARAM_IRP, irp), irpSp ); irp->CancelRoutine = NULL; } } // // Now do any checking that requires tracking data. // if (iovPacket->Flags&TRACKFLAG_QUEUED_INTERNALLY) { // // We internally queue irps to catch bugs. When we are doing this, we // force the stack returned status to STATUS_PENDING, and we queue the // irp and release it on a timer. We also may make the IRP non-touchable. // This particular caller is trying to forward an IRP he doesn't own, // and we didn't actually end up with an untouchable irp. // FAIL_CALLER_OF_IOFCALLDRIVER( (DCERROR_QUEUED_IRP_FORWARDED, DCPARAM_IRP, irp), irpSp ); } // // Figure out how many stack locations we've moved up since we've last seen // this IRP, and determine if the stack locations were copied appropriately. // We also need to see exactly how the IRP was forwarded (down the stack, // to another stack, straight to the PDO, etc). // // ADRIAO BUGBUG #07 05/11/98 - The only way to truely detect this is to // attach a filter at every layer in stack. // This is left as an exercise for later. // IovpExamineDevObjForwarding( DeviceObject, iovSessionData->DeviceLastCalled, &iovSessionData->ForwardMethod ) ; IovpExamineIrpStackForwarding( iovPacket, isNewSession, iovSessionData->ForwardMethod, DeviceObject, irp, &irpSp, &irpLastSp, &locationsAdvanced ); TRACKIRP_DBGPRINT(( " CD1: Current, Last = (%x, %x)\n", irp->CurrentLocation, iovPacket->LastLocation ), 3) ; // // Figure out whether this is a new request or not, and record a // pointer in this slot to the requests originating slot as appropriate. // isNewRequest = IovpAssertIsNewRequest(irpLastSp, irpSp); // // Record information in our private stack locations and // write that back into the "stack" data itself... // previouslyInUse = IovpAdvanceStackDownwards( iovSessionData->StackData, irp->CurrentLocation, irpSp, irpLastSp, locationsAdvanced, isNewRequest, TRUE, &iovCurrentStackLocation ); ASSERT(iovCurrentStackLocation); if (previouslyInUse) { ASSERT(!isNewRequest); ASSERT(!isNewSession); KeQuerySystemTime(&iovCurrentStackLocation->PerfDispatchStart) ; } else { IofCallDriverStackData->Flags = CALLFLAG_TOPMOST_IN_SLOT ; InitializeListHead(&IofCallDriverStackData->SharedLocationList) ; KeQuerySystemTime(&iovCurrentStackLocation->PerfDispatchStart) ; KeQuerySystemTime(&iovCurrentStackLocation->PerfStackLocationStart) ; // // Record the first thread this IRP slot was dispatched to. // iovCurrentStackLocation->ThreadDispatchedTo = PsGetCurrentThread(); if (isNewRequest) { iovCurrentStackLocation->InitialStatusBlock = irp->IoStatus; iovCurrentStackLocation->LastStatusBlock = irp->IoStatus; if (isNewSession) { iovCurrentStackLocation->Flags |= STACKFLAG_FIRST_REQUEST; } } } // // Record whether this is the last device object for this IRP... // PDO's have devnodes filled out, so look for that field. // Actually, we can't quite do that trick as during Bus // enumeration a bus filter might be sending down Irps before // the OS has ever seen the node. So we assume a devobj is a // PDO if he has never attached to anyone. // lowerDeviceObject = IovpGetDeviceAttachedTo(DeviceObject) ; if (lowerDeviceObject) { ObDereferenceObject(lowerDeviceObject) ; } else { iovCurrentStackLocation->Flags |= STACKFLAG_REACHED_PDO ; } // // Record who is getting this IRP (we will blame any mistakes on him // if this request gets completed.) Note that we've already asserted // DeviceObject is non-NULL... // driverObject = DeviceObject->DriverObject ; dispatchRoutine = driverObject->MajorFunction[irpSp->MajorFunction] ; iovCurrentStackLocation->LastDispatch = dispatchRoutine ; // // Uncomplete the request if we are heading back down with it... // iovCurrentStackLocation->Flags &=~ STACKFLAG_REQUEST_COMPLETED ; // // This IofCallDriver2 dude will need to be told what his status should // be later. Add him to the linked list of addresses to scribble away // stati when the appropriate level is completed. // InsertHeadList( &iovCurrentStackLocation->CallStackData, &IofCallDriverStackData->SharedLocationList ) ; // // More IofCallDriver2 stuff, tell him the stack location. // IofCallDriverStackData->IovStackLocation = iovCurrentStackLocation ; // If it's a remove IRP, mark everyone appropriately if ((irpSp->MajorFunction == IRP_MJ_PNP)&& (irpSp->MinorFunction == IRP_MN_REMOVE_DEVICE)) { IofCallDriverStackData->Flags |= CALLFLAG_IS_REMOVE_IRP ; pdo = IovpGetLowestDevice(DeviceObject) ; ASSERT(pdo) ; IofCallDriverStackData->RemovePdo = pdo ; ObDereferenceObject(pdo) ; if (IovpIsInFdoStack(DeviceObject) && (!(DeviceObject->DeviceObjectExtension->ExtensionFlags&DOE_RAW_FDO))) { IofCallDriverStackData->Flags |= CALLFLAG_REMOVING_FDO_STACK_DO ; } } if ((iovPacket->AssertFlags&ASSERTFLAG_POLICEIRPS) && (iovPacket->AssertFlags&ASSERTFLAG_MONITORMAJORS)) { // // Do IRP-major specific assertions as appropriate // if (isNewSession) { IovpAssertNewIrps(iovPacket, irpSp, iovCurrentStackLocation) ; } if (isNewRequest) { IovpAssertNewRequest(iovPacket, DeviceObject, irpLastSp, irpSp, iovCurrentStackLocation) ; } IovpAssertIrpStackDownward(iovPacket, DeviceObject, irpLastSp, irpSp, iovCurrentStackLocation) ; } // // Update our fields // iovSessionData->DeviceLastCalled = DeviceObject ; iovPacket->LastLocation = irp->CurrentLocation ; iovCurrentStackLocation->RequestsFirstStackLocation->LastStatusBlock = irp->IoStatus; // // Dope the next stack location so we can detect usage of // IoCopyCurrentIrpStackLocationToNext or IoSetCompletionRoutine. // if (irp->CurrentLocation>1) { IoSetNextIrpStackLocation( irp ) ; irpSp = IoGetNextIrpStackLocation( irp ); irpSp->Control |= SL_NOTCOPIED ; IoSkipCurrentIrpStackLocation( irp ) ; } // // Randomly set the cancel flag on a percentage of forwarded IRPs. Many // drivers queue first and after dequeue assume the cancel routine they // set must have been cleared if Cancel = TRUE. They don't handle the case // were the Irp was cancelled in flight. // // ADRIAO BUGBUG 07/16/1999 - // Do better spontaneous cancel logic later. // if ((IovpInitFlags & IOVERIFIERINIT_RANDOMLY_CANCEL_IRPS) && (!(irp->Flags & IRP_PAGING_IO))) { if (((++IovpCancelCount) % 4000) == 0) { irp->Cancel = TRUE; } } // // Assert LastLocation is consistent with an IRP that may be completed. // ASSERT(iovSessionData->StackData[iovPacket->LastLocation-1].InUse) ; IovpSessionDataReference(iovSessionData); IovpTrackingDataReleaseLock(iovPacket) ; }

VOID FASTCALL IovpCallDriver2 (  IN PIRP  Irp, IN PDEVICE_OBJECT  DeviceObject, IN PVOID  Routine, IN OUT NTSTATUS *  FinalStatus, IN PIOFCALLDRIVER_STACKDATA  IofCallDriverStackData )

Definition at line 948 of file trackirp.c. References ASSERT, ASSERTFLAG_FORCEPENDING, ASSERTFLAG_POLICEIRPS, _IOV_SESSION_DATA::AssertFlags, _IOV_SESSION_DATA::BestVisibleIrp, CALLFLAG_COMPLETED, CALLFLAG_IS_REMOVE_IRP, CALLFLAG_OVERRIDE_STATUS, CALLFLAG_REMOVING_FDO_STACK_DO, _IOV_STACK_LOCATION::CallStackData, DCERROR_BUS_FILTER_ERRONEOUSLY_DELETED, DCERROR_BUS_FILTER_ERRONEOUSLY_DETACHED, DCERROR_DELETED_PRESENT_PDO, DCERROR_INCONSISTANT_STATUS, DCERROR_IRP_RETURNED_WITHOUT_COMPLETION, DCERROR_SHOULDVE_DELETED, DCERROR_SHOULDVE_DETACHED, DCERROR_UNINITIALIZED_STATUS, DCPARAM_DEVOBJ, DCPARAM_IRP, DCPARAM_ROUTINE, DCPARAM_STATUS, DNF_DEVICE_GONE, DOE_DELETE_PENDING, FALSE, _IOV_REQUEST_PACKET::Flags, _DEVICE_NODE::Flags, _IOV_STACK_LOCATION::InUse, IovpGetDeviceAttachedTo(), IovpSessionDataDereference(), IovpTrackingDataAcquireLock(), IovpTrackingDataReleaseLock(), _IOV_SESSION_DATA::IovRequestPacket, NTSTATUS(), NULL, ObDereferenceObject, PsGetCurrentThread, SESSIONFLAG_UNWOUND_INCONSISTANT, _IOV_SESSION_DATA::SessionFlags, _IOV_STACK_LOCATION::ThreadDispatchedTo, TRACKFLAG_UNWOUND_BADLY, TRACKIRP_DBGPRINT, TRUE, and WDM_FAIL_ROUTINE. : This routine is called by IofCallDriver just after the driver's dispatch routine has been called. The IRP may not be touchable at this time. Arguments: Irp - A pointer to the IRP passed into IofCallDriver. The IRP may not be touchable right now. DispatchRoutine - Dispatch routine that was called by IofCallDriver. FinalStatus - A pointer to the status returned by the dispatch routine. This may be changed if all IRPs are being forced "pending". IofCallDriverStackData - Pointer to a local variable on IofCallDriver's stack to retreive data stored by IovpCallDriver1. Return Value: None. --*/ { NTSTATUS status, lastStatus; PIOV_REQUEST_PACKET iovPacket; PIOV_SESSION_DATA iovSessionData; ULONG refCount; PIOV_STACK_LOCATION iovCurrentStackLocation; BOOLEAN mustDetachAndDelete; PDEVICE_NODE devNode; PDEVICE_OBJECT lowerDevObj; iovSessionData = IofCallDriverStackData->IovSessionData; if (iovSessionData == NULL) { return; } iovPacket = iovSessionData->IovRequestPacket; ASSERT(iovPacket); IovpTrackingDataAcquireLock(iovPacket); // // ADRIAO BUGBUG 08/10/1999 - // This needs to be reenabled once the DNF_ flags are used in a // consistant manner. // #if 0 if (iovSessionData->AssertFlags&ASSERTFLAG_POLICEIRPS) { if (IofCallDriverStackData->Flags&CALLFLAG_IS_REMOVE_IRP) { if ((*FinalStatus != STATUS_PENDING) && (iovCurrentStackLocation->ThreadDispatchedTo == PsGetCurrentThread())) { lowerDevObj = IovpGetDeviceAttachedTo(DeviceObject) ; // // We can look at this because the caller has committed to this being // completed now, and we are on the original thread. // // N.B. This works because all the objects in the stack have been // referenced during a remove. If we decide to only reference the // top object, this logic would break... // if (IofCallDriverStackData->Flags&CALLFLAG_REMOVING_FDO_STACK_DO) { // // FDO, Upper, & Lower filters *must* go. Note that lowerDevObj // should be null as we should have detached. // mustDetachAndDelete = TRUE ; } else { devNode = IofCallDriverStackData->RemovePdo->DeviceObjectExtension->DeviceNode ; ASSERT(devNode) ; if (devNode->Flags & DNF_DEVICE_GONE) { // // It's been reported as missing. It *must* go! // mustDetachAndDelete = TRUE ; } else { // // It must stay! // mustDetachAndDelete = FALSE ; } } if (mustDetachAndDelete) { // // IoDetachDevice and IoDeleteDevice should have been called. // First verify IoDetachDevice... // if (lowerDevObj) { WDM_FAIL_ROUTINE(( DCERROR_SHOULDVE_DETACHED, DCPARAM_IRP + DCPARAM_ROUTINE + DCPARAM_DEVOBJ, iovSessionData->BestVisibleIrp, DispatchRoutine, DeviceObject )); } // // Now verify IoDeleteDevice // if (!(DeviceObject->DeviceObjectExtension->ExtensionFlags&DOE_DELETE_PENDING)) { WDM_FAIL_ROUTINE(( DCERROR_SHOULDVE_DELETED, DCPARAM_IRP + DCPARAM_ROUTINE + DCPARAM_DEVOBJ, iovSessionData->BestVisibleIrp, DispatchRoutine, DeviceObject )); } } else { // // Did we mistakenly leave? Verify we aren't a bus filter that // has been fooled. In that case, no checking can be done... // ASSERT(!(IofCallDriverStackData->Flags&CALLFLAG_REMOVING_FDO_STACK_DO)) ; if (DeviceObject == IofCallDriverStackData->RemovePdo) { // // Check PDO's - did we mistakenly delete ourselves? // if (DeviceObject->DeviceObjectExtension->ExtensionFlags&DOE_DELETE_PENDING) { WDM_FAIL_ROUTINE(( DCERROR_DELETED_PRESENT_PDO, DCPARAM_IRP + DCPARAM_ROUTINE + DCPARAM_DEVOBJ, iovSessionData->BestVisibleIrp, DispatchRoutine, DeviceObject )); } } else if (!(IofCallDriverStackData->RemovePdo->DeviceObjectExtension->ExtensionFlags&DOE_DELETE_PENDING)) { // // Check bus filters. Bus filters better not have detached // or deleted themselves, as the PDO is still present! // if (lowerDevObj == NULL) { // // Oops, it detached. Baad bus filter... // WDM_FAIL_ROUTINE(( DCERROR_BUS_FILTER_ERRONEOUSLY_DETACHED, DCPARAM_IRP + DCPARAM_ROUTINE + DCPARAM_DEVOBJ, iovSessionData->BestVisibleIrp, DispatchRoutine, DeviceObject )); } if (DeviceObject->DeviceObjectExtension->ExtensionFlags&DOE_DELETE_PENDING) { // // It deleted itself. Also very bad... // WDM_FAIL_ROUTINE(( DCERROR_BUS_FILTER_ERRONEOUSLY_DELETED, DCPARAM_IRP + DCPARAM_ROUTINE + DCPARAM_DEVOBJ, iovSessionData->BestVisibleIrp, DispatchRoutine, DeviceObject )); } } } if (lowerDevObj) { ObDereferenceObject(lowerDevObj) ; } } } } #endif if (IofCallDriverStackData->Flags&CALLFLAG_COMPLETED) { TRACKIRP_DBGPRINT(( " Verifying status in CD2\n" ),2) ; if ((*FinalStatus != IofCallDriverStackData->ExpectedStatus)&& (*FinalStatus != STATUS_PENDING)) { if ((iovSessionData->AssertFlags&ASSERTFLAG_POLICEIRPS) && (!(iovSessionData->SessionFlags&SESSIONFLAG_UNWOUND_INCONSISTANT))) { // // The completion routine and the return value don't match. Hey! // WDM_FAIL_ROUTINE(( DCERROR_INCONSISTANT_STATUS, DCPARAM_IRP + DCPARAM_ROUTINE + DCPARAM_STATUS*2, iovSessionData->BestVisibleIrp, DispatchRoutine, IofCallDriverStackData->ExpectedStatus, *FinalStatus )); } iovSessionData->SessionFlags |= SESSIONFLAG_UNWOUND_INCONSISTANT; } else if (*FinalStatus == 0xFFFFFFFF) { if (iovSessionData->AssertFlags&ASSERTFLAG_POLICEIRPS) { // // This status value is illegal. If we see it, we probably have // an uninitialized variable... // WDM_FAIL_ROUTINE(( DCERROR_UNINITIALIZED_STATUS, DCPARAM_IRP + DCPARAM_ROUTINE, iovSessionData->BestVisibleIrp, DispatchRoutine )); } } // // We do not need to remove ourselves from the list because // we will not be completed twice (InUse is NULL makes sure). // } else { // // OK, we haven't completed yet. Status better // be pending... // TRACKIRP_DBGPRINT(( " Verifying status is STATUS_PENDING in CR2\n" ), 2) ; if (*FinalStatus != STATUS_PENDING) { if ((iovSessionData->AssertFlags&ASSERTFLAG_POLICEIRPS) && (!(iovPacket->Flags&TRACKFLAG_UNWOUND_BADLY))) { // // We got control before this slot was completed. This is // legal as long as STATUS_PENDING was returned (it was not), // so it's bug time. Note that the IRP may not be safe to touch. // WDM_FAIL_ROUTINE(( DCERROR_IRP_RETURNED_WITHOUT_COMPLETION, DCPARAM_IRP + DCPARAM_ROUTINE, iovSessionData->BestVisibleIrp, DispatchRoutine )); } iovPacket->Flags |= TRACKFLAG_UNWOUND_BADLY; } iovCurrentStackLocation = (PIOV_STACK_LOCATION)(IofCallDriverStackData->IovStackLocation) ; ASSERT(iovCurrentStackLocation->InUse) ; ASSERT(!IsListEmpty(&iovCurrentStackLocation->CallStackData)) ; // // We now extricate ourselves from the list. // RemoveEntryList(&IofCallDriverStackData->SharedLocationList) ; } if ((IofCallDriverStackData->Flags&CALLFLAG_OVERRIDE_STATUS)&& (*FinalStatus != STATUS_PENDING)) { *FinalStatus = IofCallDriverStackData->NewStatus ; } if ((iovSessionData->AssertFlags&ASSERTFLAG_FORCEPENDING) && (!(IofCallDriverStackData->Flags&CALLFLAG_IS_REMOVE_IRP))) { // // We also have the option of causing trouble by making every Irp // look as if were pending. // *FinalStatus = STATUS_PENDING ; } IovpSessionDataDereference(iovSessionData); IovpTrackingDataReleaseLock(iovPacket); }

VOID FASTCALL IovpCancelIrp (  IN PIRP  Irp, IN OUT PBOOLEAN  CancelHandled, IN OUT PBOOLEAN  ReturnValue )

VOID FASTCALL IovpCompleteRequest1 (  IN PIRP  Irp, IN CCHAR  PriorityBoost, IN OUT PIOFCOMPLETEREQUEST_STACKDATA  CompletionPacket )

Definition at line 1267 of file trackirp.c. References ASSERT, ASSERTFLAG_FORCEPENDING, _IOV_SESSION_DATA::AssertFlags, _IRP::CurrentLocation, DCERROR_QUEUED_IRP_COMPLETED, DCERROR_UNFORWARDED_IRP_COMPLETED, DCPARAM_IRP, _IOV_SESSION_DATA::DeviceLastCalled, FALSE, _IRP::Flags, _IOV_REQUEST_PACKET::Flags, IoGetCurrentIrpStackLocation, IoMarkIrpPending, IovpAdvanceStackDownwards(), IovpTrackingDataFindAndLock(), IovpTrackingDataGetCurrentSessionData(), IovpTrackingDataReleaseLock(), _IOV_SESSION_DATA::IovRequestPacket, Irp, IRP_DIAG_HAS_SURROGATE, _IOV_REQUEST_PACKET::LastLocation, NULL, PIOFCOMPLETEREQUEST_STACKDATA, _IOV_REQUEST_PACKET::PriorityBoost, PriorityBoost, _IRP::StackCount, _IOV_SESSION_DATA::StackData, TRACKFLAG_QUEUED_INTERNALLY, TRACKIRP_DBGPRINT, WDM_CHASTISE_CALLER3, and WDM_FAIL_CALLER3. : Irp - A pointer to the IRP passed into IofCompleteRequest. PriorityBoost - The priority boost passed into IofCompleteRequest. CompletionPacket - A pointer to a local variable on the stack of IofCompleteRequest. The information stored in this local variable will be picked up by IovpCompleteRequest2-5. Return Value: None. --*/ { PIOV_REQUEST_PACKET iovPacket; PIOV_SESSION_DATA iovSessionData; BOOLEAN slotIsInUse; PIOV_STACK_LOCATION iovCurrentStackLocation; ULONG locationsAdvanced; PIO_STACK_LOCATION irpSp; PDEVICE_OBJECT lowerDevobj; iovPacket = IovpTrackingDataFindAndLock(Irp); CompletionPacket->RaisedCount = 0; if (iovPacket == NULL) { CompletionPacket->IovSessionData = NULL; return; } iovSessionData = IovpTrackingDataGetCurrentSessionData(iovPacket); CompletionPacket->IovSessionData = iovSessionData; CompletionPacket->IovRequestPacket = iovPacket; if (iovSessionData == NULL) { // // We just got a look at the allocation, not the session itself. // This can happen if a driver calls IofCompleteRequest on an internally // generated IRP before calling IofCallDriver. NPFS does this. // IovpTrackingDataReleaseLock(iovPacket); return; } TRACKIRP_DBGPRINT(( " CR1: Current, Last = (%x, %x)\n", Irp->CurrentLocation, iovPacket->LastLocation ), 3); irpSp = IoGetCurrentIrpStackLocation(Irp); if (iovPacket->Flags&TRACKFLAG_QUEUED_INTERNALLY) { // // We are probably going to die now. Anyway, it was a good life... // WDM_FAIL_CALLER3((DCERROR_QUEUED_IRP_COMPLETED, DCPARAM_IRP, Irp)); } // // This would be *very* bad - someone is completing an IRP that is // currently in progress... // ASSERT(!(Irp->Flags&IRP_DIAG_HAS_SURROGATE)); // // Hmmm, someone is completing an IRP that IoCallDriver never called. These // is possible but rather gross, so we warn. // if (Irp->CurrentLocation == ((CCHAR) Irp->StackCount + 1)) { WDM_CHASTISE_CALLER3((DCERROR_UNFORWARDED_IRP_COMPLETED, DCPARAM_IRP, Irp)); } // // Record priority for our own later recompletion... // iovPacket->PriorityBoost = PriorityBoost; // // We have the option of causing trouble by making every Irp look // as if were pending. It is best to do it here, as this also takes // care of anybody who has synchronized the IRP and thus does not need // to mark it pending in his completion routine. // if (iovSessionData->AssertFlags&ASSERTFLAG_FORCEPENDING) { IoMarkIrpPending(Irp); } // // Do this so that if the IRP comes down again, it looks like a new one // to the "forward them correctly" code. // iovSessionData->DeviceLastCalled = NULL; locationsAdvanced = iovPacket->LastLocation - Irp->CurrentLocation; // // Remember this so that we can detect the case where someone is completing // to themselves. // CompletionPacket->LocationsAdvanced = locationsAdvanced; // // If this failed, somebody skipped then completed. // ASSERT(locationsAdvanced); // // If somebody called IoSetNextIrpStackLocation, and then completed, // update our internal stack locations (slots) as appropriate. // slotIsInUse = IovpAdvanceStackDownwards( iovSessionData->StackData, Irp->CurrentLocation, irpSp, irpSp + locationsAdvanced, locationsAdvanced, FALSE, FALSE, &iovCurrentStackLocation ); IovpTrackingDataReleaseLock(iovPacket); }

VOID FASTCALL IovpCompleteRequest2 (  IN PIRP  Irp, IN OUT PIOFCOMPLETEREQUEST_STACKDATA  CompletionPacket )

Definition at line 1416 of file trackirp.c. References ASSERT, ASSERTFLAG_COMPLETEATDPC, ASSERTFLAG_MONITORMAJORS, ASSERTFLAG_POLICEIRPS, ASSERTFLAG_ROTATE_STATUS, _IOV_SESSION_DATA::AssertFlags, CALLFLAG_COMPLETED, CALLFLAG_OVERRIDE_STATUS, _IRP::CancelRoutine, _IO_STACK_LOCATION::CompletionRoutine, _IO_STACK_LOCATION::Context, _IO_STACK_LOCATION::Control, _IRP::CurrentLocation, DISPATCH_LEVEL, _IOFCALLDRIVER_STACKDATA::ExpectedStatus, FALSE, _IOFCALLDRIVER_STACKDATA::Flags, _IOV_STACK_LOCATION::Flags, _IOV_STACK_LOCATION::InUse, IoGetNextIrpStackLocation, IoSetCompletionRoutine, _IRP::IoStatus, IovpAssertDoAdvanceStatus(), IovpAssertFinalIrpStack(), IovpAssertIrpStackUpward(), IovpSessionDataClose(), IovpSessionDataDereference(), IovpSessionDataReference(), IovpSwapSurrogateIrp(), IovpTrackingDataAcquireLock(), IovpTrackingDataDereference(), IovpTrackingDataGetCurrentSessionData(), IovpTrackingDataReleaseLock(), IOVREFTYPE_POINTER, Irp, KeRaiseIrql(), _IOFCALLDRIVER_STACKDATA::NewStatus, NTSTATUS(), NULL, _IOV_STACK_LOCATION::RequestsFirstStackLocation, _IOV_SESSION_DATA::StackData, STACKFLAG_REQUEST_COMPLETED, TRACKFLAG_SURROGATE, TRACKIRP_DBGPRINT, and TRUE. : This routine is called for each stack location that might have a completion routine. Arguments: Irp - A pointer to the IRP passed into IofCompleteRequest. CompletionPacket - A pointer to a local variable on the stack of IofCompleteRequest. The information stored in this local variable will be picked up by IovpCompleteRequest4&5. Return Value: None. --*/ { PIOV_REQUEST_PACKET iovPacket; PIOV_SESSION_DATA iovSessionData; BOOLEAN raiseToDPC, newlyCompleted, requestFinalized ; KIRQL oldIrql ; PIOV_STACK_LOCATION iovCurrentStackLocation, requestsFirstStackLocation ; NTSTATUS status, entranceStatus ; PIOFCALLDRIVER_STACKDATA IofCallDriverStackData ; PIO_STACK_LOCATION irpSp ; ULONG refAction ; PLIST_ENTRY listEntry ; iovSessionData = CompletionPacket->IovSessionData; if (iovSessionData == NULL) { return; } iovPacket = CompletionPacket->IovRequestPacket; ASSERT(iovPacket); IovpTrackingDataAcquireLock(iovPacket); ASSERT(iovSessionData == IovpTrackingDataGetCurrentSessionData(iovPacket)); ASSERT(!Irp->CancelRoutine) ; status = Irp->IoStatus.Status ; TRACKIRP_DBGPRINT(( " CR2: Current, Last = (%x, %x)\n", Irp->CurrentLocation, iovPacket->LastLocation ), 3) ; iovCurrentStackLocation = iovSessionData->StackData + Irp->CurrentLocation -1 ; TRACKIRP_DBGPRINT(( " Smacking %lx in CR2\n", iovCurrentStackLocation-iovSessionData->StackData ), 2) ; if (Irp->CurrentLocation <= iovPacket->TopStackLocation) { // // Might this be false if the completion routine is to an // internal stack loc as set up by IoSetNextIrpStackLocation? // ASSERT(iovCurrentStackLocation->InUse) ; // // Determine if a request was newly completed. Note that // several requests may exist within an IRP if it is being // "reused". For instance, in response to a IRP_MJ_READ, a // driver might convert it into a IRP_MJ_PNP request for the // rest of the stack. The two are treated as seperate requests. // requestsFirstStackLocation = iovCurrentStackLocation->RequestsFirstStackLocation ; TRACKIRP_DBGPRINT(( " CR2: original request for %lx is %lx\n", iovCurrentStackLocation-iovSessionData->StackData, requestsFirstStackLocation-iovSessionData->StackData ), 3) ; ASSERT(requestsFirstStackLocation) ; if (requestsFirstStackLocation->Flags&STACKFLAG_REQUEST_COMPLETED) { newlyCompleted = FALSE ; } else { requestsFirstStackLocation->Flags|=STACKFLAG_REQUEST_COMPLETED ; newlyCompleted = TRUE ; TRACKIRP_DBGPRINT(( " CR2: Request %lx newly completed by %lx\n", requestsFirstStackLocation-iovSessionData->StackData, iovCurrentStackLocation-iovSessionData->StackData ), 3) ; } requestFinalized = (iovCurrentStackLocation == requestsFirstStackLocation) ; if (requestFinalized) { TRACKIRP_DBGPRINT(( " CR2: Request %lx finalized\n", iovCurrentStackLocation-iovSessionData->StackData ), 3) ; } // // OK - // If we haven't unwound yet, then IofCallDriverStackData will // start out non-NULL, in which case we will scribble away the final // completion routine status to everybody asking (could be multiple // if they IoSkip'd). // On the other hand, everybody might have unwound, in which // case IofCallDriver(...) will start out NULL, and we will already have // asserted if STATUS_PENDING wasn't returned much much earlier... // Finally, this slot may not have been "prepared" if an // internal stack location called IoSetNextIrpStackLocation, thus // consuming a stack location. In this case, IofCallDriverStackData // will come from a zero'd slot, and we will do nothing, which is // also fine. // irpSp = IoGetNextIrpStackLocation(Irp) ; if ((iovPacket->AssertFlags&ASSERTFLAG_POLICEIRPS) && (iovPacket->AssertFlags&ASSERTFLAG_MONITORMAJORS)) { IovpAssertIrpStackUpward( iovPacket, irpSp, iovCurrentStackLocation, newlyCompleted, requestFinalized ); } entranceStatus = status ; while(!IsListEmpty(&iovCurrentStackLocation->CallStackData)) { // // Pop off the list head. // listEntry = RemoveHeadList(&iovCurrentStackLocation->CallStackData) ; IofCallDriverStackData = CONTAINING_RECORD( listEntry, IOFCALLDRIVER_STACKDATA, SharedLocationList) ; ASSERT(!(IofCallDriverStackData->Flags&CALLFLAG_COMPLETED)) ; IofCallDriverStackData->Flags |= CALLFLAG_COMPLETED ; IofCallDriverStackData->ExpectedStatus = status ; if ((iovSessionData->AssertFlags&ASSERTFLAG_ROTATE_STATUS)&& IovpAssertDoAdvanceStatus(irpSp, entranceStatus, &status)) { // // Purposely munge the returned status for everyone at this // layer to flush more bugs. We are specifically trolling for // this buggy sequence: // Irp->IoStatus.Status = STATUS_SUCCESS ; // IoSkipCurrentIrpStackLocation(Irp); // IoCallDriver(DeviceBelow, Irp) ; // return STATUS_SUCCESS ; // IofCallDriverStackData->Flags |= CALLFLAG_OVERRIDE_STATUS ; IofCallDriverStackData->NewStatus = status ; } } Irp->IoStatus.Status = status ; // // Set InUse = FALSE and CallStackData = NULL // RtlZeroMemory(iovCurrentStackLocation, sizeof(IOV_STACK_LOCATION)) ; InitializeListHead(&iovCurrentStackLocation->CallStackData) ; } else { ASSERT(0) ; } // // Once we return, we may be completed again before IofCompleteRequest3 // get's called, so we make sure we are at DPC level throughout. // raiseToDPC = FALSE ; if (iovSessionData->AssertFlags&ASSERTFLAG_COMPLETEATDPC) { if (!CompletionPacket->RaisedCount) { // // Copy away the callers IRQL // CompletionPacket->PreviousIrql = iovPacket->CallerIrql; raiseToDPC = TRUE ; } CompletionPacket->RaisedCount++ ; } iovPacket->LastLocation = Irp->CurrentLocation+1 ; if (iovPacket->TopStackLocation == Irp->CurrentLocation) { CompletionPacket->IovSessionData = NULL; if (iovPacket->Flags&TRACKFLAG_SURROGATE) { // // Scribble away the real completion routine and corrosponding control // irpSp = IoGetNextIrpStackLocation(Irp) ; iovPacket->RealIrpCompletionRoutine = irpSp->CompletionRoutine ; iovPacket->RealIrpControl = irpSp->Control ; iovPacket->RealIrpContext = irpSp->Context ; // // We want to peek at the Irp prior to completion. This is why we // have expanded the initial number of stack locations with the // driver verifier enabled. // IoSetCompletionRoutine( Irp, IovpSwapSurrogateIrp, Irp, TRUE, TRUE, TRUE ) ; } else { // // Close this session as the IRP has entirely completed. We drop // the pointer count we added to the tracking data here for the // same reason. // irpSp = IoGetNextIrpStackLocation(Irp) ; if (iovPacket->AssertFlags&ASSERTFLAG_POLICEIRPS) { IovpAssertFinalIrpStack(iovPacket, irpSp) ; } ASSERT(iovPacket->TopStackLocation == Irp->CurrentLocation); IovpSessionDataClose(iovSessionData); IovpSessionDataDereference(iovSessionData); IovpTrackingDataDereference(iovPacket, IOVREFTYPE_POINTER); } } else { // // We will be seeing this IRP again. Hold a session count against it. // IovpSessionDataReference(iovSessionData); } // // Assert LastLocation is consistent with an IRP that may be completed. // if (iovPacket->LastLocation < iovPacket->TopStackLocation) { ASSERT(iovSessionData->StackData[iovPacket->LastLocation-1].InUse) ; } IovpTrackingDataReleaseLock(iovPacket); if (raiseToDPC) { KeRaiseIrql(DISPATCH_LEVEL, &oldIrql); } CompletionPacket->LocationsAdvanced --; }

VOID FASTCALL IovpCompleteRequest3 (  IN PIRP  Irp, IN PVOID  Routine, IN OUT PIOFCOMPLETEREQUEST_STACKDATA  CompletionPacket )

Definition at line 1693 of file trackirp.c. References ASSERT, ASSERTFLAG_COMPLETEATPASSIVE, ASSERTFLAG_DEFERCOMPLETION, ASSERTFLAG_FORCEPENDING, ASSERTFLAG_POLICEIRPS, _IOV_SESSION_DATA::AssertFlags, _IO_STACK_LOCATION::CompletionRoutine, _IO_STACK_LOCATION::Context, _IRP::CurrentLocation, DbgPrint, DCERROR_COMPLETION_ROUTINE_PAGABLE, DCPARAM_IRP, DCPARAM_ROUTINE, DEFERRAL_CONTEXT, ExAllocatePoolWithTag, FALSE, IoGetCurrentIrpStackLocation, IoGetNextIrpStackLocation, IovpInternalDeferredCompletion(), IovpTrackingDataAcquireLock(), IovpTrackingDataReference(), IovpTrackingDataReleaseLock(), IOVREFTYPE_POINTER, _DEFERRAL_CONTEXT::IovRequestPacket, _IOV_SESSION_DATA::IovRequestPacket, Irp, IRP_MJ_PNP, IRP_MN_REMOVE_DEVICE, _DEFERRAL_CONTEXT::IrpSpNext, _IO_STACK_LOCATION::MajorFunction, _IO_STACK_LOCATION::MinorFunction, MmIsSystemAddressLocked(), NonPagedPool, NULL, _DEFERRAL_CONTEXT::OriginalCompletionRoutine, _DEFERRAL_CONTEXT::OriginalContext, _DEFERRAL_CONTEXT::OriginalIrp, _DEFERRAL_CONTEXT::OriginalPriorityBoost, PDEFERRAL_CONTEXT, POOL_TAG_DEFERRED_CONTEXT, _IOV_REQUEST_PACKET::PriorityBoost, _IRP::StackCount, and WDM_FAIL_ROUTINE. : This routine is called just before each completion routine is invoked. Arguments: Irp - A pointer to the IRP passed into IofCompleteRequest. Routine - The completion routine about to be called. CompletionPacket - A pointer to data on the callers stack. This will be picked up IovpCompleteRequest4 and IovpCompleteRequest5. Return Value: None. --*/ { PIOV_REQUEST_PACKET iovPacket; PIOV_SESSION_DATA iovSessionData; PIO_STACK_LOCATION irpSpCur, irpSpNext ; PDEFERRAL_CONTEXT deferralContext ; iovSessionData = CompletionPacket->IovSessionData; if (iovSessionData == NULL) { return; } iovPacket = iovSessionData->IovRequestPacket; ASSERT(iovPacket); IovpTrackingDataAcquireLock(iovPacket); // // Verify all completion routines are in nonpaged code, exempting one // special case - when a driver completes the IRP to itself by calling // IoSetNextStackLocation before calling IoCompleteRequest. // if (iovSessionData->AssertFlags&ASSERTFLAG_POLICEIRPS) { if ((CompletionPacket->LocationsAdvanced <= 0) && (MmIsSystemAddressLocked(Routine) == FALSE)) { DbgPrint( "Verifier Notes: LocationsAdvanced %d\n", CompletionPacket->LocationsAdvanced ); WDM_FAIL_ROUTINE(( DCERROR_COMPLETION_ROUTINE_PAGABLE, DCPARAM_IRP + DCPARAM_ROUTINE, Irp, Routine )); } } // // Setup fields for those assertion functions that will be called *after* // the completion routine has been called. // irpSpCur = IoGetCurrentIrpStackLocation(Irp) ; CompletionPacket->IsRemoveIrp = ((Irp->CurrentLocation <= (CCHAR) Irp->StackCount) && (irpSpCur->MajorFunction == IRP_MJ_PNP) && (irpSpCur->MinorFunction == IRP_MN_REMOVE_DEVICE)) ; CompletionPacket->CompletionRoutine = Routine ; // // Is this a completion routine that should be called later? Note that this // is only legal if we are pending the IRPs (because to the upper driver, // IofCallDriver is returning before it's completion routine has been called) // if ((!CompletionPacket->IsRemoveIrp)&& ((iovSessionData->AssertFlags&ASSERTFLAG_DEFERCOMPLETION)|| (iovSessionData->AssertFlags&ASSERTFLAG_COMPLETEATPASSIVE))) { ASSERT(iovSessionData->AssertFlags&ASSERTFLAG_FORCEPENDING) ; irpSpNext = IoGetNextIrpStackLocation(Irp) ; deferralContext = ExAllocatePoolWithTag( NonPagedPool, sizeof(DEFERRAL_CONTEXT), POOL_TAG_DEFERRED_CONTEXT ) ; if (deferralContext) { // // Swap the original completion and context for our own. // deferralContext->IovRequestPacket = iovPacket; deferralContext->IrpSpNext = irpSpNext; deferralContext->OriginalCompletionRoutine = irpSpNext->CompletionRoutine; deferralContext->OriginalContext = irpSpNext->Context; deferralContext->OriginalIrp = Irp; deferralContext->OriginalPriorityBoost = iovPacket->PriorityBoost; irpSpNext->CompletionRoutine = IovpInternalDeferredCompletion; irpSpNext->Context = deferralContext; IovpTrackingDataReference(iovPacket, IOVREFTYPE_POINTER); } } IovpTrackingDataReleaseLock(iovPacket) ; }

VOID FASTCALL IovpCompleteRequest4 (  IN PIRP  Irp, IN NTSTATUS  ReturnedStatus, IN OUT PIOFCOMPLETEREQUEST_STACKDATA  CompletionPacket )

Definition at line 1813 of file trackirp.c. References ASSERT, ASSERTFLAG_FORCEPENDING, _IOV_SESSION_DATA::AssertFlags, _IO_STACK_LOCATION::Control, DCERROR_PENDING_BIT_NOT_MIGRATED, DCPARAM_IRP, DCPARAM_ROUTINE, IoGetCurrentIrpStackLocation, IoMarkIrpPending, IovpTrackingDataAcquireLock(), IovpTrackingDataReleaseLock(), _IOV_SESSION_DATA::IovRequestPacket, Irp, NULL, _IOV_REQUEST_PACKET::pIovSessionData, SL_PENDING_RETURNED, and WDM_FAIL_ROUTINE. : This assert routine is called just after each completion routine is invoked (but not if STATUS_MORE_PROCESSING is returned) Arguments: Irp - A pointer to the IRP passed into IofCompleteRequest. Routine - The completion routine called. ReturnedStatus - The status value returned. CompletionPacket - A pointer to data on the callers stack. This was filled in by IovpCompleteRequest3. Return Value: None. --*/ { PIOV_REQUEST_PACKET iovPacket; PIOV_SESSION_DATA iovSessionData; PIO_STACK_LOCATION irpSp; PVOID routine; routine = CompletionPacket->CompletionRoutine; iovSessionData = CompletionPacket->IovSessionData; if (iovSessionData == NULL) { return; } iovPacket = iovSessionData->IovRequestPacket; ASSERT(iovPacket); IovpTrackingDataAcquireLock(iovPacket); // // ADRIAO BUGBUG 01/06/1999 - // Check for leaked Cancel routines here. // if (iovSessionData->AssertFlags&ASSERTFLAG_FORCEPENDING) { // // ADRIAO BUGBUG #05 05/12/98 - Find a way to do this in the non-pend // everything path... // if ((ReturnedStatus != STATUS_MORE_PROCESSING_REQUIRED)&& (iovPacket->pIovSessionData == iovSessionData)) { // // At this point, we know the completion routine is required to have // set the IRP pending bit, because we've hardwired everyone below // him to return pending, and we've marked the pending returned bit. // Verify he did his part // irpSp = IoGetCurrentIrpStackLocation(Irp) ; if (!(irpSp->Control & SL_PENDING_RETURNED )) { WDM_FAIL_ROUTINE(( DCERROR_PENDING_BIT_NOT_MIGRATED, DCPARAM_IRP + DCPARAM_ROUTINE, Irp, routine )); // // This will keep the IRP above from erroneously asserting (and // correctly hanging). // IoMarkIrpPending(Irp); } } } IovpTrackingDataReleaseLock(iovPacket); }

VOID FASTCALL IovpCompleteRequest5 (  IN PIRP  Irp, IN OUT PIOFCOMPLETEREQUEST_STACKDATA  CompletionPacket )

Definition at line 1901 of file trackirp.c. References ASSERT, ASSERTFLAG_COMPLETEATDPC, _IOV_SESSION_DATA::AssertFlags, IovpSessionDataDereference(), IovpTrackingDataAcquireLock(), IovpTrackingDataReleaseLock(), _IOV_SESSION_DATA::IovRequestPacket, KeLowerIrql(), and NTSTATUS(). : This routine is called for each stack location that could have had a completion routine, after any possible completion routine has been called. Arguments: Irp - A pointer to the IRP passed into IofCompleteRequest. CompletionPacket - A pointer to a local variable on the stack of IofCompleteRequest. This information was stored by IovpCompleteRequest2 and 3. Return Value: None. --*/ { PIOV_REQUEST_PACKET iovPacket; PIOV_SESSION_DATA iovSessionData; PIOV_STACK_LOCATION iovCurrentStackLocation ; NTSTATUS status ; iovSessionData = CompletionPacket->IovSessionData; if (iovSessionData) { iovPacket = iovSessionData->IovRequestPacket; ASSERT(iovPacket); IovpTrackingDataAcquireLock(iovPacket); ASSERT((!CompletionPacket->RaisedCount) || (iovSessionData->AssertFlags&ASSERTFLAG_COMPLETEATDPC)) ; IovpSessionDataDereference(iovSessionData); IovpTrackingDataReleaseLock(iovPacket); } // // When this count is at zero, we have unnested out of every // completion routine, so it is OK to return back to our original IRQL // if (CompletionPacket->RaisedCount) { if (!(--CompletionPacket->RaisedCount)) { // // Undo IRQL madness (wouldn't want to return to // the caller at DPC, would we now?) // KeLowerIrql(CompletionPacket->PreviousIrql); } } }

VOID FASTCALL IovpCompleteRequestApc (  IN PIRP  Irp, IN PVOID  BestStackOffset )

Definition at line 1965 of file trackirp.c. References IovpTrackingDataFindAndLock(), IovpTrackingDataReleaseLock(), Irp, KeGetCurrentThread, RtlAssert(), _IRP::UserEvent, and _IRP::UserIosb. : This routine is after the APC for completing IRPs and fired. Arguments: Irp - A pointer to the IRP passed into retrieved from the APC in IopCompleteRequest. BestStackOffset - A pointer to a last parameter passed on the stack. We use this to detect the case where a driver has ignored STATUS_PENDING and left the UserIosb on it's stack. Return Value: None. --*/ { #if DBG #if defined(_X86_) PUCHAR addr; PIOV_REQUEST_PACKET iovPacket; addr = (PUCHAR)Irp->UserIosb; if ((addr > (PUCHAR)KeGetCurrentThread()->StackLimit) && (addr <= (PUCHAR)BestStackOffset)) { iovPacket = IovpTrackingDataFindAndLock(Irp) ; RtlAssert("UserIosb below stack pointer", __FILE__, (ULONG) iovPacket, "Call AdriaO"); IovpTrackingDataReleaseLock(iovPacket) ; } addr = (PUCHAR)Irp->UserEvent; if ((addr > (PUCHAR)KeGetCurrentThread()->StackLimit) && (addr <= (PUCHAR)BestStackOffset)) { iovPacket = IovpTrackingDataFindAndLock(Irp) ; RtlAssert("UserEvent below stack pointer", __FILE__, (ULONG) iovPacket, "Call AdriaO"); IovpTrackingDataReleaseLock(iovPacket) ; } #endif #endif }

VOID IovpDeleteDevice (  IN PDEVICE_OBJECT  Device  )

Definition at line 3379 of file trackirp.c. References DCERROR_DELETE_WHILE_ATTACHED, IovpGetDeviceAttachedTo(), ObDereferenceObject, and WDM_FAIL_CALLER1. { PDEVICE_OBJECT deviceBelow; // // ADRIAO BUGBUG 03/03/1999 - // Complain if the dude already deleted himself. // deviceBelow = IovpGetDeviceAttachedTo(DeviceObject); if (deviceBelow) { WDM_FAIL_CALLER1((DCERROR_DELETE_WHILE_ATTACHED, 0)); ObDereferenceObject(deviceBelow); } }

VOID IovpDetachDevice (  IN PDEVICE_OBJECT  LowerDevice  )

Definition at line 3354 of file trackirp.c. References DCERROR_DETACH_NOT_ATTACHED, DCPARAM_DEVOBJ, DOE_EXAMINED, DOE_TRACKED, _DEVOBJ_EXTENSION::ExtensionFlags, NULL, and WDM_FAIL_CALLER2. { PDEVOBJ_EXTENSION deviceExtension; if (LowerDevice->AttachedDevice == NULL) { WDM_FAIL_CALLER2((DCERROR_DETACH_NOT_ATTACHED, DCPARAM_DEVOBJ, LowerDevice)); } else { // // ADRIAO BUGBUG 01/07/1999 - // As the stack can be torn apart simulatenously from above and // below during a remove IRP, we cannot assert the below, and moreover // changes to the ExtensionFlags will have to involve walking the tree. // // ASSERT(LowerDevice->AttachedDevice->AttachedDevice == NULL); // deviceExtension = LowerDevice->AttachedDevice->DeviceObjectExtension; deviceExtension->ExtensionFlags &=~ (DOE_EXAMINED | DOE_TRACKED); } }

BOOLEAN FASTCALL IovpDoAssertIrps (  VOID   )

Definition at line 404 of file trackirp.c. References ASSERT, DISPATCH_LEVEL, IoVerifierInit(), IOVERIFIERINIT_ASYNCHRONOUSINIT, IOVERIFIERINIT_EVERYTHING_TRACKED, IOVERIFIERINIT_NO_REINIT, IovpIrpTrackingEnabled, and IovpTrackingFlags. : This routine is called to ensure we can do IRP assertions. When called we lock the neccessary data structures and code if we haven't been initialized. Arguments: None Return Value: TRUE if assertions can be done, FALSE otherwise (e.g., called at DPC time and we weren't already enabled) --*/ { ASSERT(IovpTrackingFlags); ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL) ; // // If we aren't enabled, call the enabling function. This is harmless to // call repeatedly. We are not gaurenteed to be enabled when this function // returns (it can't block anyway, as paging might need to occur, and we'd // be sitting on file system IRPs). The IOVERIFIERINIT_EVERYTHING_TRACKED is // used to let us know we caught all IRPs, ie none are outstanding that // haven't been tracked/marked in some manner. We can set this here as // SPECIALIRP_MARK_NON_TRACKABLE() is called in the normal IofCallDriver // code paths if SPECIAL_IRP's are enabled. // if (!IovpIrpTrackingEnabled) { #if 0 IoVerifierInit( DRIVER_VERIFIER_IO_CHECKING, IOVERIFIERINIT_EVERYTHING_TRACKED | IOVERIFIERINIT_ASYNCHRONOUSINIT | IOVERIFIERINIT_NO_REINIT ); #endif } // // If enabled, return so. // return IovpIrpTrackingEnabled; }

BOOLEAN IovpEnumDevObjCallback (  IN PVOID  Object, IN PUNICODE_STRING  ObjectName, IN ULONG  HandleCount, IN ULONG  PointerCount, IN PVOID  Context )

Definition at line 3413 of file trackirp.c. References _DEVICE_OBJECT::DeviceObjectExtension, DOE_EXAMINED, DOE_TRACKED, _DEVOBJ_EXTENSION::ExtensionFlags, and TRUE. Referenced by IovpReexamineAllStacks(). { PDEVICE_OBJECT deviceObject; PDEVOBJ_EXTENSION deviceExtension; deviceObject = (PDEVICE_OBJECT) Object; deviceExtension = deviceObject->DeviceObjectExtension; if (PointerCount || HandleCount) { deviceExtension->ExtensionFlags &=~ (DOE_EXAMINED | DOE_TRACKED); } return TRUE; }

VOID FASTCALL IovpExamineDevObjForwarding (  IN PDEVICE_OBJECT  DeviceBeingCalled, IN PDEVICE_OBJECT  DeviceLastCalled, OUT PULONG  ForwardingTechnique )

Definition at line 3537 of file trackirp.c. References ASSERT, _DEVICE_OBJECT::AttachedDevice, CHANGED_STACKS_AT_BOTTOM, CHANGED_STACKS_MID_STACK, FORWARDED_TO_NEXT_DO, IopDatabaseLock, IovpGetDeviceAttachedTo(), NULL, ObDereferenceObject, SKIPPED_A_DO, STARTED_INSIDE_STACK, and STARTED_TOP_OF_STACK. Referenced by IovpCallDriver1(). : STARTED_TOP_OF_STACK FORWARDED_TO_NEXT_DO SKIPPED_A_DO STARTED_INSIDE_STACK CHANGED_STACKS_AT_BOTTOM CHANGED_STACKS_MID_STACK --*/ { PDEVICE_OBJECT upperDevobj, lowerObject ; ULONG result ; KIRQL irql; lowerObject = IovpGetDeviceAttachedTo(DeviceLastCalled) ; ExAcquireFastLock( &IopDatabaseLock, &irql ); // // Nice and simple. Walk the device being called // upwards and find either NULL or the last device // we called. // upperDevobj = DeviceBeingCalled->AttachedDevice ; while(upperDevobj && (upperDevobj != DeviceLastCalled)) { upperDevobj = upperDevobj->AttachedDevice ; } if (DeviceLastCalled == NULL) { // // This is a newly started IRP, was it targetted // at the top of a stack or at the middle/bottom? // result = (DeviceBeingCalled->AttachedDevice) ? STARTED_INSIDE_STACK : STARTED_TOP_OF_STACK ; } else if (upperDevobj == NULL) { // // We were forwarded the Irp beyond our own stack // result = (lowerObject) ? CHANGED_STACKS_MID_STACK : CHANGED_STACKS_AT_BOTTOM ; } else if (DeviceBeingCalled->AttachedDevice == upperDevobj) { result = FORWARDED_TO_NEXT_DO ; // // Quick assertion, if LastDevice was non-NULL, the // device under him should be the one we are calling... // ASSERT(lowerObject == DeviceBeingCalled) ; } else { // // DeviceLastCalled was found higher in the stack, but wasn't // directly above DeviceBeingCalled // result = SKIPPED_A_DO ; } ExReleaseFastLock( &IopDatabaseLock, irql ); if (lowerObject) { ObDereferenceObject(lowerObject) ; } *ForwardTechnique = result ; }

VOID IovpExamineIrpStackForwarding (  IN OUT PIOV_REQUEST_PACKET  IovPacket, IN BOOLEAN  IsNewSession, IN ULONG  ForwardMethod, IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp, IN OUT PIO_STACK_LOCATION *  IoCurrentStackLocation, OUT PIO_STACK_LOCATION *  IoLastStackLocation, OUT ULONG *  StackLocationsAdvanced )

Definition at line 2239 of file trackirp.c. References ASSERT, ASSERTFLAG_CONSUME_ALWAYS, ASSERTFLAG_POLICEIRPS, _IO_STACK_LOCATION::CompletionRoutine, _IO_STACK_LOCATION::Context, _IO_STACK_LOCATION::Control, _IRP::CurrentLocation, DCERROR_INSUFFICIENT_STACK_LOCATIONS, DCERROR_IRPSP_COPIED, DCERROR_NEXTIRPSP_DIRTY, DCERROR_UNNECCESSARY_COPY, DCPARAM_IRP, _IO_STACK_LOCATION::DeviceObject, _DEVICE_OBJECT::DriverObject, FAIL_CALLER_OF_IOFCALLDRIVER2, _IO_STACK_LOCATION::FileObject, FORWARDED_TO_NEXT_DO, HACKFLAG_FOR_SCSIPORT, IoCopyCurrentIrpStackLocationToNext, IoGetCurrentIrpStackLocation, IoGetNextIrpStackLocation, IoSetCompletionRoutine, IoSetNextIrpStackLocation, IovpHackFlags, IovpInternalCompletionTrap(), IovpSwapSurrogateIrp(), Irp, IRP_MJ_POWER, _IO_STACK_LOCATION::MajorFunction, NULL, _IO_STACK_LOCATION::Parameters, SL_NOTCOPIED, _IRP::Tail, TRUE, WDM_CHASTISE_CALLER3, and WDM_CHASTISE_CALLER5. Referenced by IovpCallDriver1(). { PIRP irp; PIO_STACK_LOCATION irpSp, irpLastSp; BOOLEAN isSameStack; ULONG locationsAdvanced; irpSp = *IoCurrentStackLocation; if (!IsNewSession) { // // We are sitting on current next being one back (-1) from // CurrentStackLocation. // locationsAdvanced = IovPacket->LastLocation-Irp->CurrentLocation ; irpLastSp = Irp->Tail.Overlay.CurrentStackLocation+(locationsAdvanced-1) ; } else { // // New IRP, so no last SP and we always advance "1" // locationsAdvanced = 1 ; irpLastSp = NULL ; } if ((!IsNewSession) && (IovPacket->AssertFlags&ASSERTFLAG_POLICEIRPS)) { // // As the control field is zeroed by IoCopyCurrentStackLocation, we // dope each stack location with the value SL_NOTCOPIED. If it is // zeroed or the IRP stack location has stayed the same, the one of // the two API's was called. Otherwise the next stack location wasn't // set up properly (I have yet to find a case otherwise)... // if ((irpSp->Control&SL_NOTCOPIED)&& IovPacket->LastLocation != Irp->CurrentLocation) { #if 0 FAIL_CALLER_OF_IOFCALLDRIVER2( (DCERROR_NEXTIRPSP_DIRTY, DCPARAM_IRP, Irp), irpSp ); #endif } // // Now check for people who copy the stack locations and forget to // wipe out previous completion routines. // if (locationsAdvanced) { // // IoCopyCurrentStackLocation copies everything but Completion, // Context, and Control // isSameStack = RtlEqualMemory(irpSp, irpLastSp, FIELD_OFFSET(IO_STACK_LOCATION, Control)) ; isSameStack &= RtlEqualMemory(&irpSp->Parameters, &irpLastSp->Parameters, FIELD_OFFSET(IO_STACK_LOCATION, DeviceObject)- FIELD_OFFSET(IO_STACK_LOCATION, Parameters)) ; isSameStack &= (irpSp->FileObject == irpLastSp->FileObject) ; // // We should *never* see this on the stack! If we do, something // quite bizarre has happened... // ASSERT(irpSp->CompletionRoutine != IovpSwapSurrogateIrp) ; if (isSameStack) { // // We caught them doing something either very bad or quite // inefficient. We can tell which based on whether there is // a completion routine. // if ((irpSp->CompletionRoutine == irpLastSp->CompletionRoutine)&& (irpSp->Context == irpLastSp->Context) && (irpSp->Control == irpLastSp->Control) && (irpSp->CompletionRoutine != NULL) && (DeviceObject->DriverObject != irpLastSp->DeviceObject->DriverObject) ) { // // Duplication of both the completion and the context // while not properly zeroing the control field is enough // to make me believe the caller has made a vexing mistake. // FAIL_CALLER_OF_IOFCALLDRIVER2( (DCERROR_IRPSP_COPIED, DCPARAM_IRP, Irp), irpSp ) ; // // Repair the stack // irpSp->CompletionRoutine = NULL ; irpSp->Control = 0 ; } else if (!irpSp->CompletionRoutine) { if (!(irpSp->Control&SL_NOTCOPIED) #ifdef HACKHACKS_ENABLED && (!(IovpHackFlags&HACKFLAG_FOR_SCSIPORT)) #endif ) { // // ADRIAO HACKHACK 06/12/98 #10 - PeterWie does this for // two reasons: // 1) It's easier to debug // 2) The space is not really recovered anyway. // // This will be an ongoing argument it seems, but #2 can // be cleverly solved if one decrements their stack // count, and #1 I've solved in Debug... // if (irpSp->MajorFunction == IRP_MJ_POWER) { // // Unwind back past PoCallDriver... // WDM_CHASTISE_CALLER5( (DCERROR_UNNECCESSARY_COPY, DCPARAM_IRP, Irp) ); } else { WDM_CHASTISE_CALLER3( (DCERROR_UNNECCESSARY_COPY, DCPARAM_IRP, Irp) ); } } IoSetCompletionRoutine( Irp, IovpInternalCompletionTrap, IoGetCurrentIrpStackLocation( Irp ), TRUE, TRUE, TRUE ) ; } } } else if (IovPacket->AssertFlags&ASSERTFLAG_CONSUME_ALWAYS) { if (ForwardMethod == FORWARDED_TO_NEXT_DO) { if (Irp->CurrentLocation<2) { FAIL_CALLER_OF_IOFCALLDRIVER2( (DCERROR_INSUFFICIENT_STACK_LOCATIONS, DCPARAM_IRP, Irp), irpSp ) ; } else { // // Back up the skip, then copy. Add a completion routine with // unique and assertable context to catch people who clumsily // Rtl-copy stack locations (we can't catch them if the caller // above used an empty stack with no completion routine)... // IoSetNextIrpStackLocation( Irp ) ; // // Set the trap... // IoCopyCurrentIrpStackLocationToNext( Irp ) ; IoSetCompletionRoutine( Irp, IovpInternalCompletionTrap, IoGetCurrentIrpStackLocation( Irp ), TRUE, TRUE, TRUE ) ; // // This is our new reality... // locationsAdvanced = 1 ; irpSp = IoGetNextIrpStackLocation( Irp ); } } } } *IoCurrentStackLocation = irpSp; *IoLastStackLocation = irpLastSp; *StackLocationsAdvanced = locationsAdvanced; }

VOID FASTCALL IovpFinalizeIrpSettings (  IN OUT PIOV_REQUEST_PACKET  IrpTrackingData, IN BOOLEAN  SurrogateIrpSwapped )

VOID FASTCALL IovpFreeIrp (  IN PIRP  Irp, IN OUT PBOOLEAN  FreeHandled )

Definition at line 2990 of file trackirp.c. References _IRP::AllocationFlags, ASSERT, ASSERTFLAG_POLICEIRPS, _IOV_REQUEST_PACKET::AssertFlags, DCERROR_FREE_OF_INUSE_IRP, DCERROR_FREE_OF_THREADED_IRP, DCPARAM_IRP, FALSE, _IOV_REQUEST_PACKET::Flags, IovpProtectedIrpFree(), IovpProtectedIrpMakeUntouchable(), IovpTrackingDataDereference(), IovpTrackingDataFindAndLock(), IovpTrackingDataGetCurrentSessionData(), IovpTrackingDataReleaseLock(), IOVREFTYPE_POINTER, Irp, IRP_ALLOCATION_MONITORED, NULL, _IOV_REQUEST_PACKET::PointerCount, _IRP::ThreadListEntry, TRACKFLAG_IO_ALLOCATED, TRACKFLAG_PROTECTEDIRP, TRACKFLAG_UNWOUND_BADLY, TRUE, _IRP::Type, and WDM_FAIL_CALLER2. : This routine is called by IoFreeIrp and returns TRUE iff the free was handled internally here (in which case IoFreeIrp should do nothing). We need to handle the call internally because we may turn off lookaside list cacheing to catch people reusing IRPs after they are freed. Arguments: Irp - A pointer to the IRP passed into IoCancelIrp. FreeHandled - Indicates whether the free operation was handled entirely by this routine. Return Value: None. --*/ { PIOV_REQUEST_PACKET iovPacket; PVOID restoreHandle ; iovPacket = IovpTrackingDataFindAndLock(Irp); if (iovPacket == NULL) { // // ADRIAO BUGBUG 01/06/1999 - // Below assertion might fire if an IRP allocated then freed twice. // ASSERT(!(Irp->AllocationFlags&IRP_ALLOCATION_MONITORED)); *FreeHandled = FALSE ; return; } if (!IsListEmpty(&Irp->ThreadListEntry)) { if (iovPacket->AssertFlags&ASSERTFLAG_POLICEIRPS) { WDM_FAIL_CALLER2( (DCERROR_FREE_OF_THREADED_IRP, DCPARAM_IRP, Irp) ); } // // <Grumble> keep us alive by not actually freeing the IRP if someone did // this to us. We leak for life... // *FreeHandled = TRUE ; return ; } if (IovpTrackingDataGetCurrentSessionData(iovPacket)) { // // If there's a current session, that means someone is freeing an IRP // that they don't own. Of course, if the stack unwound badly because // someone forgot to return PENDING or complete the IRP, then we don't // assert here (we'd probably end up blaiming kernel). // if ((iovPacket->AssertFlags&ASSERTFLAG_POLICEIRPS) && (!(iovPacket->Flags&TRACKFLAG_UNWOUND_BADLY))) { WDM_FAIL_CALLER2( (DCERROR_FREE_OF_INUSE_IRP, DCPARAM_IRP, Irp) ); } // // <Grumble> keep us alive by not actually freeing the IRP if someone did // this to us. We leak for life... // IovpTrackingDataReleaseLock(iovPacket) ; *FreeHandled = TRUE ; return ; } if (!(iovPacket->Flags&TRACKFLAG_IO_ALLOCATED)) { // // We weren't tracking this at allocation time. We shouldn't got our // packet unless the IRP had a pointer count still, meaning it's has // a session. And that should've been caught above. // ASSERT(0); IovpTrackingDataReleaseLock(iovPacket) ; *FreeHandled = FALSE ; return; } // // The IRP may have been reinitialized, possibly losing it's allocation // flags. We catch this bug in the IoInitializeIrp hook. // //ASSERT(Irp->AllocationFlags&IRP_ALLOCATION_MONITORED) ; // if (!(iovPacket->Flags&TRACKFLAG_PROTECTEDIRP)) { // // We're just tagging along this IRP. Drop our pointer count but bail. // IovpTrackingDataDereference(iovPacket, IOVREFTYPE_POINTER); IovpTrackingDataReleaseLock(iovPacket); *FreeHandled = FALSE; return; } // // Set up a nice bugcheck for those who free their IRPs twice. This is done // because the special pool may have been exhausted, in which case the IRP // can be touched after it has been freed. // Irp->Type = 0; ASSERT(iovPacket) ; ASSERT(iovPacket->AssertFlags&ASSERTFLAG_POLICEIRPS); IovpTrackingDataDereference(iovPacket, IOVREFTYPE_POINTER); ASSERT(iovPacket->PointerCount == 0); IovpTrackingDataReleaseLock(iovPacket) ; restoreHandle = IovpProtectedIrpMakeUntouchable(Irp, TRUE) ; IovpProtectedIrpFree(Irp, &restoreHandle) ; // // We handled allocation and initialization. There is nothing much more to // do. // *FreeHandled = TRUE ; }

PDEVICE_OBJECT FASTCALL IovpGetDeviceAttachedTo (  IN PDEVICE_OBJECT  DeviceObject  )

Definition at line 3620 of file trackirp.c. References _DEVOBJ_EXTENSION::AttachedTo, IopDatabaseLock, NULL, and ObReferenceObject. Referenced by IovpCallDriver1(), IovpCallDriver2(), IovpDeleteDevice(), and IovpExamineDevObjForwarding(). { PDEVOBJ_EXTENSION deviceExtension; PDEVICE_OBJECT deviceAttachedTo ; KIRQL irql ; if (DeviceObject == NULL) { return NULL ; } ExAcquireFastLock( &IopDatabaseLock, &irql ); deviceExtension = DeviceObject->DeviceObjectExtension; deviceAttachedTo = deviceExtension->AttachedTo ; if (deviceAttachedTo) { ObReferenceObject(deviceAttachedTo) ; } ExReleaseFastLock( &IopDatabaseLock, irql ); return deviceAttachedTo ; }

PDEVICE_OBJECT FASTCALL IovpGetLowestDevice (  IN PDEVICE_OBJECT  DeviceObject  )

Definition at line 3648 of file trackirp.c. References _DEVOBJ_EXTENSION::AttachedTo, _DEVICE_OBJECT::DeviceObjectExtension, IopDatabaseLock, and ObReferenceObject. Referenced by IovpAssertNewRequest(), IovpAssertNonLegacyDevice(), IovpCallDriver1(), and IovpThrowChaffAtStartedPdoStack(). { PDEVOBJ_EXTENSION deviceExtension; PDEVICE_OBJECT lowerDevobj, deviceAttachedTo ; KIRQL irql ; deviceAttachedTo = DeviceObject ; ExAcquireFastLock( &IopDatabaseLock, &irql ); do { lowerDevobj = deviceAttachedTo ; deviceExtension = lowerDevobj->DeviceObjectExtension; deviceAttachedTo = deviceExtension->AttachedTo ; } while ( deviceAttachedTo ); ObReferenceObject(lowerDevobj) ; ExReleaseFastLock( &IopDatabaseLock, irql ); return lowerDevobj ; }

VOID FASTCALL IovpInitializeIrp (  IN OUT PIRP  Irp, IN USHORT  PacketSize, IN CCHAR  StackSize, IN OUT PBOOLEAN  InitializeHandled )

Definition at line 3268 of file trackirp.c. References _IRP::AllocationFlags, ASSERTFLAG_POLICEIRPS, _IOV_REQUEST_PACKET::AssertFlags, DCERROR_REINIT_OF_ALLOCATED_IRP_WITH_QUOTA, DCPARAM_IRP, FALSE, _IOV_REQUEST_PACKET::Flags, IovpTrackingDataFindAndLock(), IovpTrackingDataReleaseLock(), Irp, IRP_QUOTA_CHARGED, NULL, TRACKFLAG_IO_ALLOCATED, and WDM_FAIL_CALLER2. : This routine is called by IoInitializeIrp and sets InitializeHandled to TRUE if the entire initialization was handled internally. While here we verify the caller is not Initializing an IRP allocated through IoAllocateIrp, as doing so means we may leak quota/etc. Arguments: Irp - Irp to initialize PacketSize - Size of the IRP in bytes. StackSize - Count of stack locations for this IRP. InitializeHandled - Pointer to a BOOLEAN that will be set to true iff the initialization of the IRP was handled entirely within this routine. If FALSE, IoInitializeIrp should initialize the IRP as normal. Return Value: None. --*/ { PIOV_REQUEST_PACKET iovPacket ; iovPacket = IovpTrackingDataFindAndLock(Irp); if (iovPacket == NULL) { *InitializeHandled = FALSE ; return; } if ((iovPacket->AssertFlags&ASSERTFLAG_POLICEIRPS) && (iovPacket->Flags&TRACKFLAG_IO_ALLOCATED)) { if (Irp->AllocationFlags&IRP_QUOTA_CHARGED) { // // Don't let us leak quota now! // WDM_FAIL_CALLER2( (DCERROR_REINIT_OF_ALLOCATED_IRP_WITH_QUOTA, DCPARAM_IRP, Irp) ); } else { // // In this case we are draining our lookaside lists erroneously. // // WDM_CHASTISE_CALLER2( // (DCERROR_REINIT_OF_ALLOCATED_IRP_WITHOUT_QUOTA, DCPARAM_IRP, Irp) // ); } } *InitializeHandled = FALSE ; IovpTrackingDataReleaseLock(iovPacket) ; }

BOOLEAN FASTCALL IovpInitIrpTracking (  IN ULONG  Level, IN ULONG  Flags )

Definition at line 257 of file trackirp.c. References ASSERTFLAG_COMPLETEATDPC, ASSERTFLAG_CONSUME_ALWAYS, ASSERTFLAG_DEFERCOMPLETION, ASSERTFLAG_FORCEPENDING, ASSERTFLAG_MONITOR_ALLOCS, ASSERTFLAG_MONITORMAJORS, ASSERTFLAG_POLICEIRPS, ASSERTFLAG_ROTATE_STATUS, ASSERTFLAG_SEEDSTACK, ASSERTFLAG_SMASH_SRBS, ASSERTFLAG_SURROGATE, ASSERTFLAG_TRACKIRPS, HACKFLAG_FOR_ACPI, HACKFLAG_FOR_BOGUSIRPS, HACKFLAG_FOR_MUP, HACKFLAG_FOR_SCSIPORT, IOVERIFIERINIT_EVERYTHING_TRACKED, IOVERIFIERINIT_NO_REINIT, IovpHackFlags, IovpInitFlags, IovpIrpTrackingEnabled, IovpTrackingDataInit(), IovpTrackingFlags, PAGED_CODE, and TRUE. Referenced by IoVerifierInit(). : Initialize that which needs to be initialized. Arguments: Level - Level of testing to apply 0 - No checks 1 - Tracking with surrogate irp allocation 2 - Monitors basic IRP mistakes 3 - Monitors mistakes based on the irp major Surrogate IRPs used, status values rotated, and various other checks. 4 - IRPs always completed at DPC. 5 - All IRPs pended with completion defered via timer. 6 - Any hacks turned off. Return Value: Returns TRUE iff settings were successfully applied. --*/ { PVOID sectionHeaderHandle; ULONG newTrackingFlags; PAGED_CODE(); if (IovpIrpTrackingEnabled) { IovpInitFlags = (Flags | (IovpInitFlags&IOVERIFIERINIT_EVERYTHING_TRACKED)); } else { IovpTrackingDataInit(); IovpInitFlags = Flags; IovpIrpTrackingEnabled = TRUE; } newTrackingFlags = 0; switch(Level) { default: case 7: IovpHackFlags = 0; case 6: newTrackingFlags |= ASSERTFLAG_FORCEPENDING | ASSERTFLAG_DEFERCOMPLETION; // // Fall through // case 5: newTrackingFlags |= ASSERTFLAG_COMPLETEATDPC; // // Fall through // case 4: newTrackingFlags |= ASSERTFLAG_SURROGATE | ASSERTFLAG_SMASH_SRBS | ASSERTFLAG_CONSUME_ALWAYS | ASSERTFLAG_ROTATE_STATUS | ASSERTFLAG_SEEDSTACK; // // Fall through // case 3: newTrackingFlags |= ASSERTFLAG_MONITORMAJORS; // // Fall through // case 2: newTrackingFlags |= ASSERTFLAG_POLICEIRPS; // // Fall through // case 1: newTrackingFlags |= ASSERTFLAG_TRACKIRPS | ASSERTFLAG_MONITOR_ALLOCS; // // Fall through // case 0: break; } if ((Level == 0) && (Flags&IOVERIFIERINIT_NO_REINIT)) { // // Preinit flags // newTrackingFlags = IovpTrackingFlags; } if (IovpHackFlags == (ULONG) -1) { IovpHackFlags = #ifdef HACKHACKS_ENABLED #ifdef HACKHACK_FOR_MUP HACKFLAG_FOR_MUP | #endif #ifdef HACKHACK_FOR_SCSIPORT HACKFLAG_FOR_SCSIPORT | #endif #ifdef HACKHACK_FOR_ACPI HACKFLAG_FOR_ACPI | #endif #ifdef HACKHACK_FOR_BOGUSIRPS HACKFLAG_FOR_BOGUSIRPS | #endif #endif // HACKHACKS_ENABLED 0; } if (!(IovpInitFlags & IOVERIFIERINIT_EVERYTHING_TRACKED)) { // // These options aren't available unless we were marking IRPs since // boot. // newTrackingFlags &=~ ( ASSERTFLAG_MONITORMAJORS | ASSERTFLAG_SURROGATE | ASSERTFLAG_SMASH_SRBS | ASSERTFLAG_CONSUME_ALWAYS ); } IovpTrackingFlags = newTrackingFlags; return TRUE; }

VOID IovpInternalCompleteAfterWait (  IN PVOID  Context  )

Definition at line 2499 of file trackirp.c. References ASSERT, _IO_STACK_LOCATION::CompletionRoutine, _IO_STACK_LOCATION::Context, _DEFERRAL_CONTEXT::DeferAction, DEFERACTION_QUEUE_PASSIVE_TIMER, _DEFERRAL_CONTEXT::DeferralTimer, _DEFERRAL_CONTEXT::DeviceObject, Executive, ExFreePool(), FALSE, _IOV_REQUEST_PACKET::Flags, IoCompleteRequest, IoGetNextIrpStackLocation, IovpProtectedIrpMakeTouchable(), IovpTrackingDataAcquireLock(), IovpTrackingDataDereference(), IovpTrackingDataReleaseLock(), IOVREFTYPE_POINTER, _DEFERRAL_CONTEXT::IovRequestPacket, _DEFERRAL_CONTEXT::IrpSpNext, KernelMode, KeWaitForSingleObject(), NTSTATUS(), NULL, _DEFERRAL_CONTEXT::OriginalCompletionRoutine, _DEFERRAL_CONTEXT::OriginalContext, _DEFERRAL_CONTEXT::OriginalIrp, _DEFERRAL_CONTEXT::OriginalPriorityBoost, PASSIVE_LEVEL, _IOV_REQUEST_PACKET::RestoreHandle, and TRACKFLAG_QUEUED_INTERNALLY. Referenced by IovpInternalCompleteAtDPC(), and IovpInternalDeferredCompletion(). { PDEFERRAL_CONTEXT deferralContext = (PDEFERRAL_CONTEXT) Context ; PIO_STACK_LOCATION irpSpNext ; NTSTATUS status ; if (deferralContext->DeferAction == DEFERACTION_QUEUE_PASSIVE_TIMER) { // // Wait the appropriate amount of time if so ordered... // ASSERT(KeGetCurrentIrql()==PASSIVE_LEVEL) ; KeWaitForSingleObject( &deferralContext->DeferralTimer, Executive, KernelMode, FALSE, NULL ) ; } IovpTrackingDataAcquireLock(deferralContext->IovRequestPacket) ; IovpProtectedIrpMakeTouchable( deferralContext->OriginalIrp, &deferralContext->IovRequestPacket->RestoreHandle ); irpSpNext = IoGetNextIrpStackLocation( deferralContext->OriginalIrp ) ; ASSERT(irpSpNext == deferralContext->IrpSpNext) ; ASSERT(irpSpNext->CompletionRoutine == deferralContext->OriginalCompletionRoutine) ; ASSERT(irpSpNext->Context == deferralContext->OriginalContext) ; ASSERT(deferralContext->IovRequestPacket->Flags & TRACKFLAG_QUEUED_INTERNALLY) ; deferralContext->IovRequestPacket->Flags &=~ TRACKFLAG_QUEUED_INTERNALLY ; IovpTrackingDataDereference(deferralContext->IovRequestPacket, IOVREFTYPE_POINTER) ; IovpTrackingDataReleaseLock(deferralContext->IovRequestPacket) ; status = irpSpNext->CompletionRoutine( deferralContext->DeviceObject, deferralContext->OriginalIrp, irpSpNext->Context ) ; if (status!=STATUS_MORE_PROCESSING_REQUIRED) { IoCompleteRequest(deferralContext->OriginalIrp, deferralContext->OriginalPriorityBoost) ; } ExFreePool(deferralContext) ; }

VOID IovpInternalCompleteAtDPC (  IN PKDPC  Dpc, IN PVOID  DeferredContext, IN PVOID  SystemArgument1, IN PVOID  SystemArgument2 )

Definition at line 2488 of file trackirp.c. References IovpInternalCompleteAfterWait(). Referenced by IovpInternalDeferredCompletion(). { IovpInternalCompleteAfterWait(DeferredContext) ; }

NTSTATUS IovpInternalCompletionTrap (  IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp, IN PVOID  Context )

Definition at line 2446 of file trackirp.c. References ASSERT, IoGetCurrentIrpStackLocation, IoMarkIrpPending, Irp, and _IRP::PendingReturned. Referenced by IovpExamineIrpStackForwarding(). : This routine does nothing but act as a trap for people incorrectly copying stack locations... Arguments: DeviceObject - Device object set at this level of the completion routine - ignored. Irp - A pointer to the IRP. Context - Context should equal the Irp's stack location - this is asserted. Return Value: STATUS_SUCCESS --*/ { PIO_STACK_LOCATION irpSp ; if (Irp->PendingReturned) { IoMarkIrpPending( Irp ) ; } irpSp = IoGetCurrentIrpStackLocation( Irp ) ; ASSERT((PVOID) irpSp == Context) ; return STATUS_SUCCESS ; }

NTSTATUS IovpInternalDeferredCompletion (  IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp, IN PVOID  Context )

Definition at line 2555 of file trackirp.c. References ASSERT, ASSERTFLAG_COMPLETEATDPC, ASSERTFLAG_COMPLETEATPASSIVE, ASSERTFLAG_DEFERCOMPLETION, ASSERTFLAG_FORCEPENDING, ASSERTFLAG_POLICEIRPS, _IOV_REQUEST_PACKET::AssertFlags, _IO_STACK_LOCATION::CompletionRoutine, _IO_STACK_LOCATION::Context, DCERROR_COMPLETION_ROUTINE_PAGABLE, DCPARAM_IRP, DCPARAM_ROUTINE, DEFER_ACTION, _DEFERRAL_CONTEXT::DeferAction, DEFERACTION_NORMAL, DEFERACTION_QUEUE_DISPATCH_TIMER, DEFERACTION_QUEUE_PASSIVE_TIMER, DEFERACTION_QUEUE_WORKITEM, _DEFERRAL_CONTEXT::DeferralTimer, DelayedWorkQueue, _DEFERRAL_CONTEXT::DeviceObject, DISPATCH_LEVEL, _DEFERRAL_CONTEXT::DpcItem, ExFreePool(), ExInitializeWorkItem, ExQueueWorkItem(), FALSE, _IOV_REQUEST_PACKET::Flags, IoGetNextIrpStackLocation, IovpInternalCompleteAfterWait(), IovpInternalCompleteAtDPC(), IovpInternalDeferredCompletion(), IovpIrpDeferralTime, IovpProtectedIrpMakeUntouchable(), IovpTrackingDataAcquireLock(), IovpTrackingDataDereference(), IovpTrackingDataReleaseLock(), IOVREFTYPE_POINTER, _DEFERRAL_CONTEXT::IovRequestPacket, Irp, KDASSERT, KeInitializeDpc(), KeInitializeTimerEx(), KeSetTimerEx(), MmIsSystemAddressLocked(), NULL, _DEFERRAL_CONTEXT::OriginalCompletionRoutine, _DEFERRAL_CONTEXT::OriginalContext, PASSIVE_LEVEL, _IOV_REQUEST_PACKET::RestoreHandle, TRACKFLAG_QUEUED_INTERNALLY, WDM_FAIL_ROUTINE, and _DEFERRAL_CONTEXT::WorkQueueItem. Referenced by IovpCompleteRequest3(), and IovpInternalDeferredCompletion(). 02562 : 02563 02564 This function is slipped in as a completion routine when we are 02565 "deferring" completion via work item, etc. 02566 02567 Arguments: 02568 02569 DeviceObject - Device object set at this level of the completion 02570 routine - passed on. 02571 02572 Irp - A pointer to the IRP. 02573 02574 Context - Context block that includes original completion 02575 routine. 02576 02577 Return Value: 02578 02579 NTSTATUS 02580 02581 --*/ 02582 { 02583 PDEFERRAL_CONTEXT deferralContext = (PDEFERRAL_CONTEXT) Context; 02584 PIO_STACK_LOCATION irpSpNext; 02585 BOOLEAN passiveCompletionOK; 02586 DEFER_ACTION deferAction; 02587 ULONG refAction; 02588 ULONG trackingFlags; 02589 LARGE_INTEGER deltaTime; 02590 02591 // 02592 // Do delta time conversion. 02593 // 02594 deltaTime.QuadPart = - IovpIrpDeferralTime ; 02595 02596 // 02597 // The *next* stack location holds our completion and context. The current 02598 // stack location has already been wiped. 02599 // 02600 irpSpNext = IoGetNextIrpStackLocation( Irp ) ; 02601 02602 ASSERT((PVOID) irpSpNext->CompletionRoutine == IovpInternalDeferredCompletion) ; 02603 02604 // 02605 // Put everything back in case someone is looking... 02606 // 02607 irpSpNext->CompletionRoutine = deferralContext->OriginalCompletionRoutine ; 02608 irpSpNext->Context = deferralContext->OriginalContext ; 02609 02610 // 02611 // Some IRP dispatch routines cannot be called at passive. Two examples are 02612 // paging IRPs (cause we could switch) and Power IRPs. As we don't check yet, 02613 // if we "were" completed passive, continue to do so, but elsewhere... 02614 // 02615 passiveCompletionOK = (KeGetCurrentIrql()==PASSIVE_LEVEL) ; 02616 02617 IovpTrackingDataAcquireLock(deferralContext->IovRequestPacket) ; 02618 02619 // 02620 // Verify all completion routines are in nonpaged code. 02621 // 02622 if (deferralContext->IovRequestPacket->AssertFlags&ASSERTFLAG_POLICEIRPS) { 02623 02624 if (MmIsSystemAddressLocked(irpSpNext->CompletionRoutine) == FALSE) { 02625 02626 WDM_FAIL_ROUTINE(( 02627 DCERROR_COMPLETION_ROUTINE_PAGABLE, 02628 DCPARAM_IRP + DCPARAM_ROUTINE, 02629 Irp, 02630 irpSpNext->CompletionRoutine 02631 )) ; 02632 } 02633 } 02634 02635 trackingFlags = deferralContext->IovRequestPacket->AssertFlags; 02636 02637 ASSERT(trackingFlags&ASSERTFLAG_FORCEPENDING) ; 02638 02639 switch(trackingFlags&(ASSERTFLAG_DEFERCOMPLETION| 02640 ASSERTFLAG_COMPLETEATPASSIVE| 02641 ASSERTFLAG_COMPLETEATDPC)) { 02642 02643 case ASSERTFLAG_COMPLETEATPASSIVE: 02644 deferAction = passiveCompletionOK ? DEFERACTION_QUEUE_WORKITEM : 02645 DEFERACTION_NORMAL ; 02646 break; 02647 02648 case ASSERTFLAG_DEFERCOMPLETION | ASSERTFLAG_COMPLETEATPASSIVE: 02649 deferAction = passiveCompletionOK ? DEFERACTION_QUEUE_PASSIVE_TIMER : 02650 DEFERACTION_NORMAL ; 02651 break; 02652 02653 case ASSERTFLAG_DEFERCOMPLETION | ASSERTFLAG_COMPLETEATDPC: 02654 deferAction = DEFERACTION_QUEUE_DISPATCH_TIMER ; 02655 break; 02656 02657 case ASSERTFLAG_DEFERCOMPLETION: 02658 deferAction = (KeGetCurrentIrql()==DISPATCH_LEVEL) ? 02659 DEFERACTION_QUEUE_DISPATCH_TIMER : 02660 DEFERACTION_QUEUE_PASSIVE_TIMER ; 02661 break; 02662 02663 default: 02664 deferAction = DEFERACTION_NORMAL ; 02665 KDASSERT(0) ; 02666 } 02667 02668 if (deferAction != DEFERACTION_NORMAL) { 02669 02670 // 02671 // Set this flag. If anybody uses this IRP while this flag is on, complain 02672 // immediately! 02673 // 02674 ASSERT(!(trackingFlags&TRACKFLAG_QUEUED_INTERNALLY)) ; 02675 deferralContext->IovRequestPacket->Flags |= TRACKFLAG_QUEUED_INTERNALLY ; 02676 deferralContext->DeviceObject = DeviceObject ; 02677 02678 deferralContext->IovRequestPacket->RestoreHandle = 02679 IovpProtectedIrpMakeUntouchable( 02680 Irp, 02681 FALSE 02682 ) ; 02683 } else { 02684 02685 IovpTrackingDataDereference(deferralContext->IovRequestPacket, IOVREFTYPE_POINTER); 02686 } 02687 02688 IovpTrackingDataReleaseLock(deferralContext->IovRequestPacket) ; 02689 02690 deferralContext->DeferAction = deferAction ; 02691 02692 switch(deferAction) { 02693 02694 case DEFERACTION_QUEUE_PASSIVE_TIMER: 02695 KeInitializeTimerEx(&deferralContext->DeferralTimer, SynchronizationTimer) ; 02696 KeSetTimerEx( 02697 &deferralContext->DeferralTimer, 02698 deltaTime, 02699 0, 02700 NULL 02701 ) ; 02702 02703 // 02704 // Fall through... 02705 // 02706 02707 case DEFERACTION_QUEUE_WORKITEM: 02708 02709 // 02710 // Queue this up so we can complete this passively. 02711 // 02712 ExInitializeWorkItem( 02713 (PWORK_QUEUE_ITEM)&deferralContext->WorkQueueItem, 02714 IovpInternalCompleteAfterWait, 02715 deferralContext 02716 ); 02717 02718 ExQueueWorkItem( 02719 (PWORK_QUEUE_ITEM)&deferralContext->WorkQueueItem, 02720 DelayedWorkQueue 02721 ); 02722 02723 return STATUS_MORE_PROCESSING_REQUIRED ; 02724 02725 case DEFERACTION_QUEUE_DISPATCH_TIMER: 02726 02727 KeInitializeDpc( 02728 &deferralContext->DpcItem, 02729 IovpInternalCompleteAtDPC, 02730 deferralContext 02731 ); 02732 02733 KeInitializeTimerEx(&deferralContext->DeferralTimer, SynchronizationTimer) ; 02734 KeSetTimerEx( 02735 &deferralContext->DeferralTimer, 02736 deltaTime, 02737 0, 02738 &deferralContext->DpcItem 02739 ) ; 02740 return STATUS_MORE_PROCESSING_REQUIRED ; 02741 02742 case DEFERACTION_NORMAL: 02743 default: 02744 02745 ExFreePool(deferralContext) ; 02746 return irpSpNext->CompletionRoutine(DeviceObject, Irp, irpSpNext->Context) ; 02747 } 02748 }

BOOLEAN FASTCALL IovpIsInFdoStack (  IN PDEVICE_OBJECT  DeviceObject  )

Definition at line 3717 of file trackirp.c. References _DEVOBJ_EXTENSION::AttachedTo, _DEVICE_OBJECT::DeviceObjectExtension, DOE_BOTTOM_OF_FDO_STACK, _DEVOBJ_EXTENSION::ExtensionFlags, IopDatabaseLock, and NULL. Referenced by IovpCallDriver1(). { PDEVOBJ_EXTENSION deviceExtension; PDEVICE_OBJECT deviceAttachedTo, lowerDevobj ; KIRQL irql ; deviceAttachedTo = DeviceObject ; ExAcquireFastLock( &IopDatabaseLock, &irql ); do { if (deviceAttachedTo->DeviceObjectExtension->ExtensionFlags&DOE_BOTTOM_OF_FDO_STACK) { break; } deviceAttachedTo = deviceAttachedTo->DeviceObjectExtension->AttachedTo ; } while ( deviceAttachedTo ); ExReleaseFastLock( &IopDatabaseLock, irql ); return (deviceAttachedTo != NULL) ; }

BOOLEAN IovpIsInterestingDriver (  IN PDRIVER_OBJECT  DriverObject  )

Definition at line 3521 of file trackirp.c. References IOVERIFIERINIT_VERIFIER_DRIVER_LIST, IovpInitFlags, MmIsDriverVerifying(), and TRUE. Referenced by IovpIsInterestingStack(). { if (IovpInitFlags&IOVERIFIERINIT_VERIFIER_DRIVER_LIST) { return (BOOLEAN) MmIsDriverVerifying(DriverObject); } else { return TRUE; } }

BOOLEAN IovpIsInterestingStack (  IN PDEVICE_OBJECT  DeviceObject  )

Definition at line 3436 of file trackirp.c. References _DEVICE_OBJECT::AttachedDevice, _DEVOBJ_EXTENSION::AttachedTo, _DEVICE_OBJECT::DeviceObjectExtension, DOE_EXAMINED, DOE_TRACKED, _DEVICE_OBJECT::DriverObject, _DEVOBJ_EXTENSION::ExtensionFlags, FALSE, IopDatabaseLock, IovpIsInterestingDriver(), and TRUE. Referenced by IovpSessionDataDeterminePolicy(). { PDEVOBJ_EXTENSION deviceExtension; PDEVICE_OBJECT currentDevObj, deviceAttachedTo; BOOLEAN stackIsInteresting; KIRQL irql; // // Walk downward until we find the PDO or an examined device object. // ExAcquireFastLock( &IopDatabaseLock, &irql ); // // Quickly check the top of the stack... // if (DeviceObject->DeviceObjectExtension->ExtensionFlags & DOE_EXAMINED) { stackIsInteresting = ((DeviceObject->DeviceObjectExtension->ExtensionFlags & DOE_TRACKED) != 0); ExReleaseFastLock( &IopDatabaseLock, irql ); return stackIsInteresting; } // // OK, if the top hasn't been examined, odds are devices below it haven't // either. Walk downwards until we can determine whether the stack as a // whole should be tracked. // stackIsInteresting = FALSE; deviceAttachedTo = DeviceObject; do { currentDevObj = deviceAttachedTo; deviceExtension = currentDevObj->DeviceObjectExtension; deviceAttachedTo = deviceExtension->AttachedTo; // // Remember this... // if (IovpIsInterestingDriver(currentDevObj->DriverObject)) { stackIsInteresting = TRUE; } } while (deviceAttachedTo && (deviceAttachedTo->DeviceObjectExtension->ExtensionFlags & DOE_EXAMINED) ); if (deviceAttachedTo && (deviceAttachedTo->DeviceObjectExtension->ExtensionFlags & DOE_TRACKED)) { // // Propogate upwards the "interesting-ness" of the last examined device // in the stack... // stackIsInteresting = TRUE; } // // Walk upwards, marking everything examined and appropriately tracked. // do { deviceExtension = currentDevObj->DeviceObjectExtension; if (stackIsInteresting) { deviceExtension->ExtensionFlags |= DOE_TRACKED; } else { deviceExtension->ExtensionFlags &=~ DOE_TRACKED; } deviceExtension->ExtensionFlags |= DOE_EXAMINED; currentDevObj = currentDevObj->AttachedDevice; } while (currentDevObj); ExReleaseFastLock( &IopDatabaseLock, irql ); return stackIsInteresting; }

VOID IovpReexamineAllStacks (  VOID   )

Definition at line 3399 of file trackirp.c. References IoDeviceObjectType, IovpEnumDevObjCallback(), NULL, ObEnumerateObjectsByType(), and PAGED_CODE. { PAGED_CODE(); ObEnumerateObjectsByType( IoDeviceObjectType, IovpEnumDevObjCallback, NULL ); }

VOID FASTCALL IovpSeedOnePage (  VOID   )

Definition at line 3743 of file trackirp.c. References PAGE_SIZE. Referenced by IovpSeedStack(). { ULONG StackSeed[(PAGE_SIZE/sizeof(ULONG))] ; ULONG register i ; // // We use the return value 0xFFFFFFFF, as it is an illegal return value. We // are trying to catch people who don't initialize NTSTATUS, and it's also // a good pointer trap too. // for(i=0; i<(PAGE_SIZE/sizeof(ULONG)); i++) StackSeed[i]=0xFFFFFFFF ; }

VOID FASTCALL IovpSeedStack (  VOID   )

Definition at line 3784 of file trackirp.c. References ASSERTFLAG_SEEDSTACK, IovpSeedOnePage(), IovpSeedThreePages(), IovpSeedTwoPages(), IovpTrackingFlags, MmIsAddressValid(), and PAGE_SIZE. : This routine "seeds" the stack so that uninitialized variables are more easily ferreted out. ADRIAO BUGBUG 08/17/98 - This is a really neat idea that runs into a memory manager optimization. While I do find the appropriate guard page, the memory manager throws out the above touched pages on a thread switch and bring in new (and probably zero'd) ones. Arguments: None Return Value: None --*/ { int i, interruptReservedOverhead ; if (!(IovpTrackingFlags&ASSERTFLAG_SEEDSTACK)) { return ; } // // Is there room to try this before we run out of stack? We will reserve // half a page for interrupt overhead... // interruptReservedOverhead = PAGE_SIZE/2 ; // // There must be a guard page somewhere. Find it... // for(i=0; i<4; i++) { if (!MmIsAddressValid(((PUCHAR)&i)-i*PAGE_SIZE-interruptReservedOverhead)) { break; } } switch(i) { case 4: IovpSeedThreePages() ; break ; case 3: IovpSeedTwoPages() ; break ; case 2: IovpSeedOnePage() ; break ; case 1: break ; // Minimum is overhead case 0: break ; // Umm, we don't even have overhead! default: break ; } }

VOID FASTCALL IovpSeedThreePages (  VOID   )

Definition at line 3772 of file trackirp.c. References PAGE_SIZE. Referenced by IovpSeedStack(). { ULONG register i ; ULONG StackSeed[(PAGE_SIZE*3/sizeof(ULONG))] ; for(i=0; i<(PAGE_SIZE*3/sizeof(ULONG)); i++) StackSeed[i]=0xFFFFFFFF ; }

VOID FASTCALL IovpSeedTwoPages (  VOID   )

Definition at line 3760 of file trackirp.c. References PAGE_SIZE. Referenced by IovpSeedStack(). { ULONG StackSeed[(PAGE_SIZE*2/sizeof(ULONG))] ; ULONG register i ; for(i=0; i<(PAGE_SIZE*2/sizeof(ULONG)); i++) StackSeed[i]=0xFFFFFFFF ; }

NTSTATUS IovpSwapSurrogateIrp (  IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp, IN PVOID  Context )

Definition at line 2751 of file trackirp.c. References ASSERT, ASSERTFLAG_POLICEIRPS, _IOV_REQUEST_PACKET::AssertFlags, _IO_STACK_LOCATION::CompletionRoutine, _IO_STACK_LOCATION::Context, _IO_STACK_LOCATION::Control, _IRP::CurrentLocation, _IOV_REQUEST_PACKET::Flags, _IOV_REQUEST_PACKET::HeadPacket, IoCompleteRequest, IoGetCurrentIrpStackLocation, IoGetNextIrpStackLocation, IoSetNextIrpStackLocation, IoSizeOfIrp, IovpAssertFinalIrpStack(), IovpSessionDataClose(), IovpSessionDataDereference(), IovpSessionDataFinalizeSurrogate(), IovpTrackingDataDereference(), IovpTrackingDataFindAndLock(), IovpTrackingDataGetCurrentSessionData(), IovpTrackingDataReleaseLock(), IOVREFTYPE_POINTER, Irp, NTSTATUS(), NULL, _IOV_REQUEST_PACKET::PriorityBoost, _IOV_REQUEST_PACKET::RealIrpCompletionRoutine, _IOV_REQUEST_PACKET::RealIrpContext, _IOV_REQUEST_PACKET::RealIrpControl, _IRP::StackCount, _IOV_REQUEST_PACKET::SurrogateLink, _IOV_REQUEST_PACKET::TopStackLocation, _IOV_REQUEST_PACKET::TrackedIrp, TRACKFLAG_SWAPPED_BACK, and TRACKIRP_DBGPRINT. Referenced by IovpCompleteRequest2(), and IovpExamineIrpStackForwarding(). 02758 : 02759 02760 This completion routine will copy back the surrogate IRP 02761 to the original and complete the original IRP. 02762 02763 Arguments: 02764 02765 DeviceObject - Device object set at this level 02766 of the completion routine - ignored. 02767 02768 Irp - A pointer to the IRP. 02769 02770 Context - Context should equal the IRP - this is 02771 asserted. 02772 02773 Return Value: 02774 02775 STATUS_MORE_PROCESSING_REQUIRED... 02776 02777 --*/ 02778 { 02779 PIOV_REQUEST_PACKET iovPacket, iovPrevPacket; 02780 PIOV_SESSION_DATA iovSessionData; 02781 ULONG irpSize ; 02782 PIRP realIrp ; 02783 BOOLEAN freeTrackingData ; 02784 NTSTATUS status, lockedStatus ; 02785 CCHAR priorityBoost ; 02786 PVOID completionRoutine ; 02787 PIO_STACK_LOCATION irpSp ; 02788 BOOLEAN locked ; 02789 02790 // 02791 // If this one fails, somebody has probably copied the stack 02792 // inclusive with our completion routine. We should already 02793 // have caught this... 02794 // 02795 ASSERT(Irp == Context) ; 02796 02797 iovPacket = IovpTrackingDataFindAndLock(Irp) ; 02798 ASSERT(iovPacket) ; 02799 02800 if (iovPacket == NULL) { 02801 02802 return STATUS_SUCCESS ; 02803 } 02804 02805 ASSERT(iovPacket->TopStackLocation == Irp->CurrentLocation) ; 02806 02807 iovSessionData = IovpTrackingDataGetCurrentSessionData(iovPacket); 02808 ASSERT(iovSessionData); 02809 02810 // 02811 // Put everything back 02812 // 02813 ASSERT(iovPacket->HeadPacket != iovPacket); 02814 02815 iovPrevPacket = CONTAINING_RECORD( 02816 iovPacket->SurrogateLink.Blink, 02817 IOV_REQUEST_PACKET, 02818 SurrogateLink 02819 ); 02820 02821 realIrp = iovPrevPacket->TrackedIrp ; 02822 irpSize = IoSizeOfIrp( Irp->StackCount ) ; 02823 02824 // 02825 // Back the IRP stack up so that the original completion routine 02826 // is called if appropriate 02827 // 02828 IoSetNextIrpStackLocation(Irp); 02829 IoSetNextIrpStackLocation(realIrp); 02830 02831 irpSp = IoGetCurrentIrpStackLocation(Irp) ; 02832 irpSp->CompletionRoutine = iovPacket->RealIrpCompletionRoutine ; 02833 irpSp->Control = iovPacket->RealIrpControl ; 02834 irpSp->Context = iovPacket->RealIrpContext ; 02835 02836 // 02837 // Record final data and make any accesses to the surrogate IRP 02838 // crash. 02839 // 02840 irpSp = IoGetNextIrpStackLocation(Irp) ; 02841 if (iovPacket->AssertFlags&ASSERTFLAG_POLICEIRPS) { 02842 02843 IovpAssertFinalIrpStack(iovPacket, irpSp) ; 02844 } 02845 02846 priorityBoost = iovPacket->PriorityBoost ; 02847 IovpTrackingDataDereference(iovPacket, IOVREFTYPE_POINTER); 02848 IovpSessionDataFinalizeSurrogate(iovSessionData, iovPacket, Irp); 02849 IovpSessionDataClose(iovSessionData); 02850 IovpSessionDataDereference(iovSessionData); 02851 02852 TRACKIRP_DBGPRINT(( 02853 " Swapping surrogate IRP %lx back to %lx (Tracking data %lx)\n", 02854 Irp, 02855 realIrp, 02856 iovPacket 02857 ), 1) ; 02858 02859 iovPacket->Flags |= TRACKFLAG_SWAPPED_BACK ; 02860 IovpTrackingDataReleaseLock(iovPacket) ; 02861 02862 // 02863 // Send the IRP onwards and upwards. 02864 // 02865 IoCompleteRequest(realIrp, priorityBoost) ; 02866 02867 return STATUS_MORE_PROCESSING_REQUIRED ; 02868 }

---

Variable Documentation

ULONG IovpHackFlags

Definition at line 55 of file trackirp.h. Referenced by IovpExamineIrpStackForwarding(), IovpInitIrpTracking(), IovpSessionDataDeterminePolicy(), and IovpThrowChaffAtStartedPdoStack().

ULONG IovpTrackingFlags

Definition at line 56 of file trackirp.h. Referenced by IovpAllocateIrp1(), IovpAllocateIrp2(), IovpCallDriver1(), IovpDoAssertIrps(), IovpInitIrpTracking(), IovpSeedStack(), IovpSessionDataCreate(), IovpSessionDataDeterminePolicy(), and IovpTrackingDataCreateAndLock().

---