hashirp.h File Reference

Go to the source code of this file.

Defines
#define	IRP_TRACKING_HASH_SIZE   256
#define	IRP_TRACKING_HASH_PRIME   131
Typedefs
typedef enum _IOV_REFERENCE_TYPE	IOV_REFERENCE_TYPE
Enumerations
enum	_IOV_REFERENCE_TYPE { IOVREFTYPE_PACKET = 0, IOVREFTYPE_POINTER }
Functions
VOID FASTCALL	IovpTrackingDataInit (VOID)
PIOV_REQUEST_PACKET FASTCALL	IovpTrackingDataFindAndLock (IN PIRP Irp)
PIOV_REQUEST_PACKET FASTCALL	IovpTrackingDataCreateAndLock (IN PIRP Irp)
VOID FASTCALL	IovpTrackingDataFree (IN PIOV_REQUEST_PACKET IrpTrackingData)
PIOV_REQUEST_PACKET FASTCALL	IovpTrackingDataFindPointer (IN PIRP Irp, OUT PLIST_ENTRY *HashHead)
VOID FASTCALL	IovpTrackingDataAcquireLock (IN PIOV_REQUEST_PACKET IrpTrackingData)
VOID FASTCALL	IovpTrackingDataReleaseLock (IN PIOV_REQUEST_PACKET IrpTrackingData)
VOID FASTCALL	IovpTrackingDataReference (IN PIOV_REQUEST_PACKET IovPacket, IN IOV_REFERENCE_TYPE IovRefType)
VOID FASTCALL	IovpTrackingDataDereference (IN PIOV_REQUEST_PACKET IovPacket, IN IOV_REFERENCE_TYPE IovRefType)
VOID FASTCALL	IovpWatermarkIrp (IN PIRP Irp, IN ULONG Flags)
PIOV_SESSION_DATA FASTCALL	IovpTrackingDataGetCurrentSessionData (IN PIOV_REQUEST_PACKET IovPacket)
PVOID FASTCALL	IovpProtectedIrpMakeUntouchable (IN PIRP Irp OPTIONAL, IN BOOLEAN Permanent)
VOID FASTCALL	IovpProtectedIrpMakeTouchable (IN PIRP Irp, IN PVOID *RestoreHandle)
VOID FASTCALL	IovpProtectedIrpFree (IN PIRP Irp OPTIONAL, IN PVOID *RestoreHandle)
PIRP FASTCALL	IovpProtectedIrpAllocate (IN CCHAR StackSize, IN BOOLEAN ChargeQuota, IN PETHREAD QuotaThread OPTIONAL)
Variables
ULONG	IovpIrpTrackingSpewLevel

---

Define Documentation

#define IRP_TRACKING_HASH_PRIME   131

Definition at line 25 of file hashirp.h. Referenced by IovpTrackingDataFindPointer().

#define IRP_TRACKING_HASH_SIZE   256

Definition at line 24 of file hashirp.h. Referenced by IovpTrackingDataFindPointer(), and IovpTrackingDataInit().

---

Typedef Documentation

typedef enum _IOV_REFERENCE_TYPE IOV_REFERENCE_TYPE

Referenced by IovpTrackingDataReference().

---

Enumeration Type Documentation

enum _IOV_REFERENCE_TYPE

Enumeration values: IOVREFTYPE_PACKET  IOVREFTYPE_POINTER  Definition at line 31 of file hashirp.h. { IOVREFTYPE_PACKET = 0, IOVREFTYPE_POINTER } IOV_REFERENCE_TYPE;

---

Function Documentation

PIRP FASTCALL IovpProtectedIrpAllocate (  IN CCHAR  StackSize, IN BOOLEAN  ChargeQuota, IN PETHREAD QuotaThread  OPTIONAL )

Definition at line 686 of file hashirp.c. References ASSERT, ExAllocatePoolWithTagPriority(), HighPoolPrioritySpecialPoolOverrun, IoSizeOfIrp, NonPagedPool, and POOL_TAG_PROTECTED_IRP. Referenced by IovpAllocateIrp1(), and IovpSessionDataAttachSurrogate(). : This routine allocates an IRP from the special pool using the "replacement IRP" tag. Arguments: StackSize - Number of stack locations to give the new IRP ChargeQuota - TRUE iff quota should be charged against QuotaThread QuotaThread - See above Return Value: Pointer to the memory allocated. --*/ { PIRP pSurrogateIrp; ULONG_PTR irpPtr; SIZE_T sizeOfAllocation; // // We are allocating an IRP from the special pool. Since IRPs may come from // lookaside lists they may be ULONG aligned. The memory manager on the // other hand gaurentees quad-aligned allocations. So to catch all special // pool overrun bugs we "skew" the IRP right up to the edge. // sizeOfAllocation = IoSizeOfIrp(StackSize); ASSERT((sizeOfAllocation % (sizeof(ULONG))) == 0); // // ADRIAO BUGBUG 08/16/98 - Use a quota'd alloc function if one is available // later... // irpPtr = (ULONG_PTR) ExAllocatePoolWithTagPriority( NonPagedPool, sizeOfAllocation, POOL_TAG_PROTECTED_IRP, HighPoolPrioritySpecialPoolOverrun ); pSurrogateIrp = (PIRP) (irpPtr); return pSurrogateIrp; }

VOID FASTCALL IovpProtectedIrpFree (  IN PIRP Irp  OPTIONAL, IN PVOID *  RestoreHandle )

Definition at line 838 of file hashirp.c. References ASSERT, and NULL. Referenced by IovpFreeIrp(), IovpSessionDataAttachSurrogate(), and IovpSessionDataFinalizeSurrogate(). : This routine is called when the call stack has entirely unwound and the IRP has completed. At this point it is no longer really useful to hold the surrogate IRP around. As we are using the special pool currently, this routine needs to do nothing. Arguments: IrpTrackingData - Pointer to the IRP tracking data. Return Value: None. --*/ { ASSERT((*RestoreHandle) == NULL); }

VOID FASTCALL IovpProtectedIrpMakeTouchable (  IN PIRP  Irp, IN PVOID *  RestoreHandle )

Definition at line 807 of file hashirp.c. References ASSERT, Irp, MmProtectSpecialPool(), and NULL. Referenced by IovpCancelIrp(), and IovpInternalCompleteAfterWait(). : This routine makes the an IRP touchable if previously untouchable. Arguments: Irp - Pointer to the Irp to make untouchable RestoreHandle - Pointer to handle returned by IovpProtectedIrpMakeUntouchable Return Value: None. --*/ { if (*RestoreHandle) { ASSERT(*RestoreHandle == Irp); MmProtectSpecialPool(Irp, PAGE_READWRITE) ; *RestoreHandle = NULL ; } }

PVOID FASTCALL IovpProtectedIrpMakeUntouchable (  IN PIRP Irp  OPTIONAL, IN BOOLEAN  Permanent )

Definition at line 744 of file hashirp.c. References ExFreePool(), Irp, MmProtectSpecialPool(), and NULL. Referenced by IovpFreeIrp(), IovpInternalDeferredCompletion(), IovpSessionDataAttachSurrogate(), and IovpSessionDataFinalizeSurrogate(). : This routine makes the surrogate IRP untouchable. Currently, this is done by freeing the IRP back to the special pool. Arguments: Irp - Pointer to the Irp to make untouchable Permanent - TRUE iff Irp should not be made touchable again Return Value: RestoreHandle to be passed to make the Irp touchable again, or to free it. --*/ { ULONG howModified; if (!Irp) { return NULL ; } if (Permanent) { ExFreePool(Irp) ; return NULL; } howModified = (ULONG) MmProtectSpecialPool(Irp, PAGE_NOACCESS); switch(howModified) { case (ULONG) -1: // // Didn't come from special pool. // return NULL; case 0: // // Can't comply with request, ref counts, etc hold down page. // return NULL; default: // // Allocation has been successfully marked as untouchable. // return (PVOID) Irp; } }

VOID FASTCALL IovpTrackingDataAcquireLock (  IN PIOV_REQUEST_PACKET  IrpTrackingData  )

Referenced by IovpCallDriver2(), IovpCompleteRequest2(), IovpCompleteRequest3(), IovpCompleteRequest4(), IovpCompleteRequest5(), IovpInternalCompleteAfterWait(), IovpInternalDeferredCompletion(), and IovpTrackingDataFindAndLock().

PIOV_REQUEST_PACKET FASTCALL IovpTrackingDataCreateAndLock (  IN PIRP  Irp  )

Definition at line 122 of file hashirp.c. References ASSERT, _IOV_REQUEST_PACKET::AssertFlags, _IOV_REQUEST_PACKET::CallerIrql, ExAllocatePoolWithTag, _IOV_REQUEST_PACKET::Flags, _IOV_REQUEST_PACKET::HashLink, _IOV_REQUEST_PACKET::HeadPacket, IOV_REQUEST_PACKET, IOV_STACK_LOCATION, IovpIrpHashLock, IovpTrackingDataFindPointer(), IovpTrackingFlags, Irp, _IOV_REQUEST_PACKET::IrpLock, KeInitializeSpinLock(), _IOV_REQUEST_PACKET::LastLocation, NonPagedPool, NULL, _IOV_REQUEST_PACKET::pIovSessionData, _IOV_REQUEST_PACKET::PointerCount, POOL_TAG_TRACKING_DATA, _IOV_REQUEST_PACKET::PriorityBoost, _IOV_REQUEST_PACKET::RealIrpCompletionRoutine, _IOV_REQUEST_PACKET::RealIrpContext, _IOV_REQUEST_PACKET::RealIrpControl, _IOV_REQUEST_PACKET::ReferenceCount, _IOV_REQUEST_PACKET::RefTrackingCount, _IOV_REQUEST_PACKET::RestoreHandle, _IOV_REQUEST_PACKET::SessionHead, _IOV_REQUEST_PACKET::StackCount, _IRP::StackCount, _IOV_REQUEST_PACKET::SurrogateLink, _IOV_REQUEST_PACKET::TopStackLocation, _IOV_REQUEST_PACKET::TrackedIrp, and TRACKIRP_DBGPRINT. Referenced by IovpAllocateIrp1(), IovpAllocateIrp2(), IovpCallDriver1(), and IovpSessionDataAttachSurrogate(). : This routine creates a tracking packet for a new IRP. The IRP does not get an initial reference count however. IovpTrackingDataReleaseLock must be called to drop the lock. Arguments: Irp - Irp to begin tracking. Return Value: iovPacket block, NULL if no memory. --*/ { KIRQL oldIrql; PIOV_REQUEST_PACKET iovPacket; PLIST_ENTRY hashHead; ULONG trackingDataSize; LONG newCount; ExAcquireSpinLock( &IovpIrpHashLock, &oldIrql ); iovPacket = IovpTrackingDataFindPointer(Irp, &hashHead) ; ASSERT(!iovPacket) ; // // One extra stack location is allocated as the "zero'th" is used to // simplify some logic... // trackingDataSize = sizeof(IOV_REQUEST_PACKET)+Irp->StackCount*sizeof(IOV_STACK_LOCATION) ; iovPacket = ExAllocatePoolWithTag( NonPagedPool, trackingDataSize, POOL_TAG_TRACKING_DATA ); if (!iovPacket) { ExReleaseSpinLock( &IovpIrpHashLock, oldIrql ); return iovPacket; } //RtlZeroMemory(iovPacket, trackingDataSize) ; // // From top to bottom, initialize the fields. Note that there is not a // "surrogateHead". If any code needs to find out the first entry in the // circularly linked list of IRPs (the first is the only non-surrogate IRP), // then HeadPacket should be used. Note that the link to the session is // stored by the headPacket, more on this later. // iovPacket->TrackedIrp = Irp; KeInitializeSpinLock( &iovPacket->IrpLock ); iovPacket->ReferenceCount = 1; iovPacket->PointerCount = 0; iovPacket->Flags = 0; InitializeListHead(&iovPacket->HashLink); InitializeListHead(&iovPacket->SurrogateLink); InitializeListHead(&iovPacket->SessionHead); iovPacket->HeadPacket = iovPacket; iovPacket->StackCount = Irp->StackCount; iovPacket->AssertFlags = IovpTrackingFlags; iovPacket->RealIrpCompletionRoutine = NULL; iovPacket->RealIrpControl = 0; iovPacket->RealIrpContext = NULL; iovPacket->TopStackLocation = 0; iovPacket->PriorityBoost = 0; iovPacket->LastLocation = 0; iovPacket->RefTrackingCount =0; iovPacket->RestoreHandle = NULL; iovPacket->pIovSessionData = NULL; // // Place into hash table under lock (with the initial reference count) // InsertHeadList(hashHead, &iovPacket->HashLink); ExReleaseSpinLock( &IovpIrpHashLock, oldIrql ); ExAcquireSpinLock( &iovPacket->IrpLock, &iovPacket->CallerIrql ); newCount = InterlockedDecrement(&iovPacket->ReferenceCount); // // If this assert gets hit it means somebody got hold of tracking data // at a very odd (and probably buggy) time. Actually, this might happen // if an IRP was cancelled right as it entered IoCallDriver... // //ASSERT(newCount == 0); TRACKIRP_DBGPRINT(( " VRP CREATE(%x)->%x\n", Irp, iovPacket ), 3) ; return iovPacket ; }

VOID FASTCALL IovpTrackingDataDereference (  IN PIOV_REQUEST_PACKET  IovPacket, IN IOV_REFERENCE_TYPE  IovRefType )

Definition at line 612 of file hashirp.c. References ASSERT, ASSERT_SPINLOCK_HELD, IovpIrpHashLock, IOVREFTYPE_POINTER, NULL, and TRACKIRP_DBGPRINT. Referenced by IovpCompleteRequest2(), IovpFreeIrp(), IovpInternalCompleteAfterWait(), IovpInternalDeferredCompletion(), IovpSessionDataDereference(), IovpSessionDataFinalizeSurrogate(), and IovpSwapSurrogateIrp(). { KIRQL oldIrql; ASSERT_SPINLOCK_HELD(&IovPacket->IrpLock); ASSERT(IovPacket->ReferenceCount > 0); TRACKIRP_DBGPRINT(( " VRP DEREF(%x) %x--\n", IovPacket, IovPacket->ReferenceCount ), 3) ; if (IovRefType == IOVREFTYPE_POINTER) { ASSERT(IovPacket->PointerCount > 0); TRACKIRP_DBGPRINT(( " VRP DEREF2(%x) %x--\n", IovPacket, IovPacket->PointerCount ), 3) ; IovPacket->PointerCount--; if (IovPacket->PointerCount == 0) { ExAcquireSpinLock( &IovpIrpHashLock, &oldIrql ); IovPacket->TrackedIrp->Flags &=~ IRPFLAG_EXAMINE_MASK; IovPacket->TrackedIrp = NULL; ExReleaseSpinLock( &IovpIrpHashLock, oldIrql ); } } InterlockedDecrement(&IovPacket->ReferenceCount); ASSERT(IovPacket->ReferenceCount >= IovPacket->PointerCount); }

PIOV_REQUEST_PACKET FASTCALL IovpTrackingDataFindAndLock (  IN PIRP  Irp  )

Definition at line 276 of file hashirp.c. References ASSERT, _IOV_REQUEST_PACKET::CallerIrql, IovpIrpHashLock, IovpTrackingDataAcquireLock(), IovpTrackingDataFindPointer(), IovpTrackingDataReleaseLock(), Irp, NULL, _IOV_REQUEST_PACKET::ReferenceCount, _IOV_REQUEST_PACKET::TrackedIrp, and TRACKIRP_DBGPRINT. Referenced by IovpCallDriver1(), IovpCancelIrp(), IovpCompleteRequest1(), IovpCompleteRequestApc(), IovpFreeIrp(), IovpInitializeIrp(), IovpSwapSurrogateIrp(), and IovpWatermarkIrp(). : This routine will return the tracking data for an IRP that is being tracked without a surrogate or the tracking data for with a surrogate if the surrogate IRP is what was passed in. Arguments: Irp - Irp to find. Return Value: IovPacket block, iff above conditions are satified. --*/ { KIRQL oldIrql ; PIOV_REQUEST_PACKET iovPacket ; PLIST_ENTRY listHead; ASSERT(Irp) ; ExAcquireSpinLock( &IovpIrpHashLock, &oldIrql ); iovPacket = IovpTrackingDataFindPointer(Irp, &listHead) ; if (!iovPacket) { ExReleaseSpinLock( &IovpIrpHashLock, oldIrql ); return NULL; } InterlockedIncrement(&iovPacket->ReferenceCount); ExReleaseSpinLock( &IovpIrpHashLock, oldIrql ); IovpTrackingDataAcquireLock(iovPacket) ; iovPacket->CallerIrql = oldIrql; InterlockedDecrement(&iovPacket->ReferenceCount); if (iovPacket->TrackedIrp == NULL) { ASSERT(0); // // Someone IRP is being mishandled, we got in a race condition where // we got the packet but the pointer count decayed to zero. Therefore // we do not want this packet so we will return NULL after dropping // it's lock. This sort of thing really shouldn't happen ya know. // IovpTrackingDataReleaseLock(iovPacket); return NULL; } TRACKIRP_DBGPRINT(( " VRP FIND(%x)->%x\n", Irp, iovPacket ), 3) ; return iovPacket; }

PIOV_REQUEST_PACKET FASTCALL IovpTrackingDataFindPointer (  IN PIRP  Irp, OUT PLIST_ENTRY *  HashHead )

Definition at line 345 of file hashirp.c. References ASSERT_SPINLOCK_HELD, IovpIrpHashLock, IovpIrpTrackingTable, Irp, IRP_TRACKING_HASH_PRIME, IRP_TRACKING_HASH_SIZE, NULL, PAGE_SIZE, and _IOV_REQUEST_PACKET::TrackedIrp. Referenced by IovpTrackingDataCreateAndLock(), and IovpTrackingDataFindAndLock(). : This routine returns a pointer to a pointer to the Irp tracking data. This function is meant to be called by other routines in this file. N.B. The tracking lock is assumed to be held by the caller. Arguments: Irp - Irp to locate in the tracking table. HashHead - If return is non-null, points to the list head that should be used to insert the IRP. Return Value: IrpTrackingData iff found, NULL otherwise. --*/ { KIRQL oldIrql ; PIOV_REQUEST_PACKET iovPacket ; PLIST_ENTRY listEntry, listHead; UINT_PTR hash ; ASSERT_SPINLOCK_HELD(&IovpIrpHashLock) ; hash = (((UINT_PTR) Irp)/PAGE_SIZE)*IRP_TRACKING_HASH_PRIME ; hash %= IRP_TRACKING_HASH_SIZE ; *HashHead = listHead = IovpIrpTrackingTable + hash ; for(listEntry = listHead; listEntry->Flink != listHead; listEntry = listEntry->Flink) { iovPacket = CONTAINING_RECORD(listEntry->Flink, IOV_REQUEST_PACKET, HashLink); if (iovPacket->TrackedIrp == Irp) { return iovPacket; } } return NULL ; }

VOID FASTCALL IovpTrackingDataFree (  IN PIOV_REQUEST_PACKET  IrpTrackingData  )

Definition at line 232 of file hashirp.c. References ASSERT, ExFreePool(), TRACKFLAG_REMOVED_FROM_TABLE, and TRACKIRP_DBGPRINT. Referenced by IovpTrackingDataReleaseLock(). : This routine free's the tracking data. The tracking data should already have been removed from the table by a call to IovpTrackingDataReleaseLock with the ReferenceCount at 0. Arguments: IovPacket - Tracking data to free. Return Value: Nope. --*/ { // // The list entry is inited to point back to itself when removed. The // pointer count should of course still be zero. // IovPacket->Flags|=TRACKFLAG_REMOVED_FROM_TABLE ; ASSERT(IsListEmpty(&IovPacket->HashLink)) ; // // with no reference counts... // ASSERT(!IovPacket->ReferenceCount) ; ASSERT(!IovPacket->PointerCount) ; TRACKIRP_DBGPRINT(( " VRP FREE(%x)x\n", IovPacket ), 3) ; ExFreePool(IovPacket) ; }

PIOV_SESSION_DATA FASTCALL IovpTrackingDataGetCurrentSessionData (  IN PIOV_REQUEST_PACKET  IovPacket  )

Definition at line 657 of file hashirp.c. References ASSERT, ASSERT_SPINLOCK_HELD, NULL, and TRACKFLAG_ACTIVE. Referenced by IovpAssertIrpStackDownward(), IovpCallDriver1(), IovpCompleteRequest1(), IovpCompleteRequest2(), IovpFreeIrp(), IovpSessionDataFinalizeSurrogate(), and IovpSwapSurrogateIrp(). { ASSERT_SPINLOCK_HELD(&IovPacket->IrpLock); ASSERT_SPINLOCK_HELD(&IovPacket->HeadPacket->IrpLock); ASSERT((IovPacket->HeadPacket->pIovSessionData == NULL)|| (IovPacket->Flags&TRACKFLAG_ACTIVE)) ; return IovPacket->HeadPacket->pIovSessionData; }

VOID FASTCALL IovpTrackingDataInit (  VOID   )

Definition at line 89 of file hashirp.c. References IovpIrpHashLock, IovpIrpTrackingTable, IRP_TRACKING_HASH_SIZE, KeInitializeSpinLock(), and PAGED_CODE. Referenced by IovpInitIrpTracking(). : This routine initializes all the important structures we use to track IRPs through the hash tables. Arguments: None Return Value: None --*/ { ULONG i; PAGED_CODE(); KeInitializeSpinLock( &IovpIrpHashLock ); for(i=0; i<IRP_TRACKING_HASH_SIZE; i++) { InitializeListHead(IovpIrpTrackingTable+i); } }

VOID FASTCALL IovpTrackingDataReference (  IN PIOV_REQUEST_PACKET  IovPacket, IN IOV_REFERENCE_TYPE  IovRefType )

Definition at line 584 of file hashirp.c. References ASSERT_SPINLOCK_HELD, IOV_REFERENCE_TYPE, IOVREFTYPE_POINTER, and TRACKIRP_DBGPRINT. Referenced by IovpAllocateIrp1(), IovpAllocateIrp2(), IovpCallDriver1(), IovpCompleteRequest3(), IovpSessionDataAttachSurrogate(), and IovpSessionDataReference(). { ASSERT_SPINLOCK_HELD(&IovPacket->IrpLock); TRACKIRP_DBGPRINT(( " VRP REF(%x) %x++\n", IovPacket, IovPacket->ReferenceCount ), 3) ; InterlockedIncrement(&IovPacket->ReferenceCount); if (IovRefType == IOVREFTYPE_POINTER) { TRACKIRP_DBGPRINT(( " VRP REF2(%x) %x++\n", IovPacket, IovPacket->PointerCount ), 3) ; IovPacket->PointerCount++; } }

VOID FASTCALL IovpTrackingDataReleaseLock (  IN PIOV_REQUEST_PACKET  IrpTrackingData  )

Definition at line 454 of file hashirp.c. References ASSERT, ASSERT_SPINLOCK_HELD, _IOV_REQUEST_PACKET::CallerIrql, _IRP::Flags, _IOV_REQUEST_PACKET::HashLink, _IOV_REQUEST_PACKET::HeadPacket, IovpIrpHashLock, IovpTrackingDataFree(), _IOV_REQUEST_PACKET::IrpLock, NULL, _IOV_REQUEST_PACKET::pIovSessionData, _IOV_REQUEST_PACKET::PointerCount, _IOV_REQUEST_PACKET::ReferenceCount, _IOV_REQUEST_PACKET::SurrogateLink, and _IOV_REQUEST_PACKET::TrackedIrp. Referenced by IovpAllocateIrp1(), IovpAllocateIrp2(), IovpCallDriver1(), IovpCallDriver2(), IovpCancelIrp(), IovpCompleteRequest1(), IovpCompleteRequest2(), IovpCompleteRequest3(), IovpCompleteRequest4(), IovpCompleteRequest5(), IovpCompleteRequestApc(), IovpFreeIrp(), IovpInitializeIrp(), IovpInternalCompleteAfterWait(), IovpInternalDeferredCompletion(), IovpSwapSurrogateIrp(), IovpTrackingDataFindAndLock(), and IovpWatermarkIrp(). : This routine releases the IRPs tracking data lock and adjusts the ref count as appropriate. If the reference count drops to zero, the tracking data is freed. Arguments: IovPacket - Pointer to the IRP tracking data. Return Value: None. --*/ { BOOLEAN freeTrackingData; PIOV_REQUEST_PACKET iovCurPacket, iovHeadPacket, iovNextPacket; KIRQL oldIrql; // // Pass one, delink anyone from the tree who's leaving, and assert that // no surrogates are left after a freed one. // iovCurPacket = iovHeadPacket = IovPacket->HeadPacket; while(1) { ASSERT_SPINLOCK_HELD(&iovCurPacket->IrpLock); iovNextPacket = CONTAINING_RECORD( iovCurPacket->SurrogateLink.Flink, IOV_REQUEST_PACKET, SurrogateLink ); // // PointerCount is always referenced under the IRP lock. // if (iovCurPacket->PointerCount == 0) { ExAcquireSpinLock( &IovpIrpHashLock, &oldIrql ); // // This field may be examined only under the hash lock. // if (iovCurPacket->TrackedIrp) { iovCurPacket->TrackedIrp->Flags &=~ IRPFLAG_EXAMINE_MASK; iovCurPacket->TrackedIrp = NULL; } ExReleaseSpinLock( &IovpIrpHashLock, oldIrql ); } // // We now remove any entries that will be leaving from the hash table. // Note that the ReferenceCount may be incremented outside the IRP lock // (but under the hash lock) but ReferenceCount can never be dropped // outside of the IRP lock. Therefore for performance we check once // and then take the lock to prevent anyone finding it and incrementing // it. // if (iovCurPacket->ReferenceCount == 0) { ExAcquireSpinLock( &IovpIrpHashLock, &oldIrql ); if (iovCurPacket->ReferenceCount ==0) { ASSERT(iovCurPacket->PointerCount == 0); ASSERT((iovCurPacket->pIovSessionData == NULL) || (iovCurPacket != iovHeadPacket)); ASSERT((iovNextPacket->ReferenceCount == 0) || (iovNextPacket == iovHeadPacket)); RemoveEntryList(&iovCurPacket->HashLink); InitializeListHead(&iovCurPacket->HashLink); } ExReleaseSpinLock( &IovpIrpHashLock, oldIrql ); } if (iovCurPacket == IovPacket) { break; } iovCurPacket = iovNextPacket; } // // Pass two, drop locks and free neccessary data. // iovCurPacket = iovHeadPacket; while(1) { freeTrackingData = IsListEmpty(&iovCurPacket->HashLink); iovNextPacket = CONTAINING_RECORD( iovCurPacket->SurrogateLink.Flink, IOV_REQUEST_PACKET, SurrogateLink ); ExReleaseSpinLock(&iovCurPacket->IrpLock, iovCurPacket->CallerIrql) ; if (freeTrackingData) { RemoveEntryList(&iovCurPacket->SurrogateLink); InitializeListHead(&iovCurPacket->SurrogateLink); IovpTrackingDataFree(iovCurPacket) ; } if (iovCurPacket == IovPacket) { break; } iovCurPacket = iovNextPacket; } }

VOID FASTCALL IovpWatermarkIrp (  IN PIRP  Irp, IN ULONG  Flags )

Definition at line 865 of file hashirp.c. References _IOV_REQUEST_PACKET::Flags, IovpTrackingDataFindAndLock(), IovpTrackingDataReleaseLock(), Irp, IRP_BOGUS, IRP_SYSTEM_RESTRICTED, NULL, TRACKFLAG_BOGUS, and TRACKFLAG_WATERMARKED. { PIOV_REQUEST_PACKET iovPacket; iovPacket = IovpTrackingDataFindAndLock(Irp); if (iovPacket == NULL) { return; } if (Flags & IRP_SYSTEM_RESTRICTED) { // // Note that calling this function is not in itself enough to get the // system to prevent drivers from sending restricted IRPs. Those IRPs to // be protected must also be added to IovpIsSystemRestrictedIrp in // flunkirp.c // iovPacket->Flags |= TRACKFLAG_WATERMARKED; } if (Flags & IRP_BOGUS) { iovPacket->Flags |= TRACKFLAG_BOGUS; } IovpTrackingDataReleaseLock(iovPacket); }

---

Variable Documentation

ULONG IovpIrpTrackingSpewLevel

Definition at line 29 of file hashirp.h.

---