sessnirp.h File Reference

Go to the source code of this file.

Functions
PIOV_SESSION_DATA FASTCALL	IovpSessionDataCreate (IN PDEVICE_OBJECT DeviceObject, IN OUT PIOV_REQUEST_PACKET *IovPacketPointer, OUT PBOOLEAN SurrogateSpawned)
VOID FASTCALL	IovpSessionDataAdvance (IN PDEVICE_OBJECT DeviceObject, IN PIOV_SESSION_DATA IovSessionData, IN OUT PIOV_REQUEST_PACKET *IovPacketPointer, OUT PBOOLEAN SurrogateSpawned)
VOID FASTCALL	IovpSessionDataReference (IN PIOV_SESSION_DATA IovSessionData)
VOID FASTCALL	IovpSessionDataDereference (IN PIOV_SESSION_DATA IovSessionData)
VOID FASTCALL	IovpSessionDataClose (IN PIOV_SESSION_DATA IovSessionData)
VOID	IovpSessionDataDeterminePolicy (IN PIOV_REQUEST_PACKET IovRequestPacket, IN PDEVICE_OBJECT DeviceObject, OUT PBOOLEAN Trackable, OUT PBOOLEAN UseSurrogateIrp)
BOOLEAN FASTCALL	IovpSessionDataAttachSurrogate (IN OUT PIOV_REQUEST_PACKET *IovPacketPointer, IN PIOV_SESSION_DATA IovSessionData)
VOID FASTCALL	IovpSessionDataFinalizeSurrogate (IN PIOV_SESSION_DATA IovSessionData, IN OUT PIOV_REQUEST_PACKET IovPacket, IN PIRP Irp)

---

Function Documentation

VOID FASTCALL IovpSessionDataAdvance (  IN PDEVICE_OBJECT  DeviceObject, IN PIOV_SESSION_DATA  IovSessionData, IN OUT PIOV_REQUEST_PACKET *  IovPacketPointer, OUT PBOOLEAN  SurrogateSpawned )

Definition at line 140 of file sessnirp.c. References FALSE. Referenced by IovpCallDriver1(). { *SurrogateSpawned = FALSE; }

BOOLEAN FASTCALL IovpSessionDataAttachSurrogate (  IN OUT PIOV_REQUEST_PACKET *  IovPacketPointer, IN PIOV_SESSION_DATA  IovSessionData )

Definition at line 314 of file sessnirp.c. References _IRP::AllocationFlags, ASSERT, ASSERT_SPINLOCK_HELD, _IOV_REQUEST_PACKET::AssertFlags, _IOV_REQUEST_PACKET::CallerIrql, _IRP::CancelRoutine, _IRP::CurrentLocation, DISPATCH_LEVEL, FALSE, _IRP::Flags, _IO_STACK_LOCATION::Flags, _IOV_REQUEST_PACKET::Flags, _IOV_REQUEST_PACKET::HeadPacket, IO_STACK_LOCATION, IoGetCurrentIrpStackLocation, IoGetNextIrpStackLocation, IopIsMemoryRangeReadable(), _IRP::IoStatus, IOV_REQUEST_PACKET, IovpProtectedIrpAllocate(), IovpProtectedIrpFree(), IovpProtectedIrpMakeUntouchable(), IovpTrackingDataCreateAndLock(), IovpTrackingDataReference(), IOVREFTYPE_POINTER, IRP_DIAG_HAS_SURROGATE, IRP_DIAG_IS_SURROGATE, IRP_MJ_SCSI, IRP_QUOTA_CHARGED, _IOV_REQUEST_PACKET::IrpLock, _IOV_REQUEST_PACKET::LastLocation, _IO_STACK_LOCATION::MajorFunction, NULL, _IO_STACK_LOCATION::Parameters, _IOV_REQUEST_PACKET::pIovSessionData, _IRP::StackCount, _IOV_REQUEST_PACKET::SurrogateLink, _IRP::Tail, _IRP::ThreadListEntry, _IOV_REQUEST_PACKET::TopStackLocation, _IOV_REQUEST_PACKET::TrackedIrp, TRACKFLAG_ACTIVE, TRACKFLAG_HAS_SURROGATE, TRACKFLAG_SRB_MUNGED, TRACKFLAG_SURROGATE, TRUE, _IRP::UserEvent, and _IRP::UserIosb. Referenced by IovpSessionDataCreate(). : This routine creates tracking data for a new IRP. It must be called on the thread the IRP was originally sent down... Arguments: IovPacketPointer - Pointer to IRP packet to attach surrogate to. If a surrogate can be attached the packet will be updated to track the surrogate. SurrogateIrp - Prepared surrogate IRP to attach. Return Value: iovPacket block, NULL if no memory. --*/ { PIOV_REQUEST_PACKET iovSurrogatePacket, iovPacket, headPacket; PIRP surrogateIrp, irp; PIO_STACK_LOCATION irpSp; PSCSI_REQUEST_BLOCK srb; PVOID restoreHandle; CCHAR activeSize; iovPacket = *IovPacketPointer; ASSERT_SPINLOCK_HELD(&iovPacket->IrpLock); ASSERT(!(CONTAINING_RECORD( iovPacket->SurrogateLink.Flink, IOV_REQUEST_PACKET, SurrogateLink)->Flags&TRACKFLAG_SURROGATE )); ASSERT(iovPacket->Flags & TRACKFLAG_ACTIVE); irp = iovPacket->TrackedIrp; activeSize = (irp->CurrentLocation-1); ASSERT(activeSize); // // We now try to make a copy of this new IRP which we will track. We // do this so that we may free *every* tracked IRP immediately upon // completion. // Technically speaking, we only need to allocate what's left of the // stack, not the entire thing. But using the entire stack makes our // work much much easier. Specifically the session stack array may depend // on this. // // ADRIAO BUGBUG 03/04/1999 - Make this work only copying a portion of the // IRP. // surrogateIrp = IovpProtectedIrpAllocate( irp->StackCount, // activeSize (BOOLEAN) ((irp->AllocationFlags&IRP_QUOTA_CHARGED) ? TRUE : FALSE), NULL ); if (surrogateIrp == NULL) { return FALSE; } // // Now set up the new IRP - we do this here so IovpTrackingDataCreateAndLock // can peek at it's fields. Start with the IRP header. // RtlCopyMemory(surrogateIrp, irp, sizeof(IRP)); // // Adjust StackCount and CurrentLocation // surrogateIrp->StackCount = irp->StackCount; // activeSize surrogateIrp->Tail.Overlay.CurrentStackLocation = ((PIO_STACK_LOCATION) (surrogateIrp+1))+activeSize; // // Our new IRP "floats", and is not attached to any thread. // Note that all cancels due to thread death will come through the // original IRP. // InitializeListHead(&surrogateIrp->ThreadListEntry); // // Our new IRP also is not connected to user mode. // surrogateIrp->UserEvent = NULL; surrogateIrp->UserIosb = NULL; // // Now copy over only the active portions of IRP. Be very careful to not // assume that the last stack location is right after the end of the IRP, // as we may change this someday! // irpSp = (IoGetCurrentIrpStackLocation(irp)-activeSize); RtlCopyMemory(surrogateIrp+1, irpSp, sizeof(IO_STACK_LOCATION)*activeSize); // // Zero the portion of the new IRP we won't be using (this should // eventually go away). // RtlZeroMemory( ((PIO_STACK_LOCATION) (surrogateIrp+1))+activeSize, sizeof(IO_STACK_LOCATION)*(surrogateIrp->StackCount - activeSize) ); // // Now create a surrogate packet to track the new IRP. // iovSurrogatePacket = IovpTrackingDataCreateAndLock(surrogateIrp); if (iovSurrogatePacket == NULL) { // // ADRIAO BUGBUG 02/11/1999 - Need to free IRP // restoreHandle = IovpProtectedIrpMakeUntouchable(surrogateIrp, TRUE); IovpProtectedIrpFree(surrogateIrp, restoreHandle); return FALSE; } headPacket = iovPacket->HeadPacket; ASSERT(iovSurrogatePacket->CallerIrql == DISPATCH_LEVEL); irpSp = IoGetNextIrpStackLocation(irp); // // We will flag this bug later. // irp->CancelRoutine = NULL; // // Let's take advantage of the original IRP not being the thing partied on // now; store a pointer to our tracking data in the information field. We // don't use this, but it's nice when debugging... // irp->IoStatus.Information = (ULONG_PTR) iovPacket; // // ADRIAO BUGBUG #28 06/10/98 - This is absolutely *gross*, and not // deterministic enough for my tastes. // // For IRP_MJ_SCSI (ie, IRP_MJ_INTERNAL_DEVICE_CONTROL), look and see // if we have an SRB coming through. If so, fake out the OriginalRequest // IRP pointer as appropriate. // if (irpSp->MajorFunction == IRP_MJ_SCSI) { srb = irpSp->Parameters.Others.Argument1 ; if (IopIsMemoryRangeReadable(srb, SCSI_REQUEST_BLOCK_SIZE)) { if ((srb->Length == SCSI_REQUEST_BLOCK_SIZE)&&(srb->OriginalRequest == irp)) { srb->OriginalRequest = surrogateIrp ; headPacket->Flags |= TRACKFLAG_SRB_MUNGED ; } } } // // Since the replacement will never make it back to user mode (the real // IRP shall of course), we will steal a field or two for debugging info. // surrogateIrp->UserIosb = (PIO_STATUS_BLOCK) iovPacket ; // // Now that everything is built correctly, attach the surrogate. The // surrogate holds down the packet we are attaching to. When the surrogate // dies we will remove this reference. // IovpTrackingDataReference(iovPacket, IOVREFTYPE_POINTER); // // Stamp IRPs appropriately. // surrogateIrp->Flags |= IRP_DIAG_IS_SURROGATE; irp->Flags |= IRP_DIAG_HAS_SURROGATE; // // Mark packet as surrogate and inherit appropriate fields from iovPacket. // iovSurrogatePacket->Flags |= TRACKFLAG_SURROGATE | TRACKFLAG_ACTIVE; iovSurrogatePacket->pIovSessionData = iovPacket->pIovSessionData; iovSurrogatePacket->AssertFlags = iovPacket->AssertFlags; iovSurrogatePacket->HeadPacket = iovPacket->HeadPacket; iovSurrogatePacket->LastLocation = iovPacket->LastLocation; iovSurrogatePacket->TopStackLocation = irp->CurrentLocation; iovPacket->Flags |= TRACKFLAG_HAS_SURROGATE; // // Fix up IRQL's so spinlocks are released in the right order. Link'm. // iovSurrogatePacket->CallerIrql = iovPacket->CallerIrql; iovPacket->CallerIrql = DISPATCH_LEVEL; InsertTailList( &iovPacket->HeadPacket->SurrogateLink, &iovSurrogatePacket->SurrogateLink ); *IovPacketPointer = iovSurrogatePacket; return TRUE; }

VOID FASTCALL IovpSessionDataClose (  IN PIOV_SESSION_DATA  IovSessionData  )

Definition at line 220 of file sessnirp.c. References ASSERT, ASSERT_SPINLOCK_HELD, _IOV_REQUEST_PACKET::Flags, _IOV_REQUEST_PACKET::HeadPacket, _IOV_REQUEST_PACKET::IrpLock, NULL, _IOV_REQUEST_PACKET::pIovSessionData, and TRACKIRP_DBGPRINT. Referenced by IovpCompleteRequest2(), and IovpSwapSurrogateIrp(). { PIOV_REQUEST_PACKET iovPacket = IovSessionData->IovRequestPacket; ASSERT_SPINLOCK_HELD(&iovPacket->IrpLock); ASSERT(iovPacket == iovPacket->HeadPacket); ASSERT(iovPacket->pIovSessionData == IovSessionData); TRACKIRP_DBGPRINT(( " SSN CLOSE(%x)\n" ), 3) ; iovPacket->Flags &=~ TRACKFLAG_ACTIVE; iovPacket->pIovSessionData = NULL; }

PIOV_SESSION_DATA FASTCALL IovpSessionDataCreate (  IN PDEVICE_OBJECT  DeviceObject, IN OUT PIOV_REQUEST_PACKET *  IovPacketPointer, OUT PBOOLEAN  SurrogateSpawned )

Definition at line 27 of file sessnirp.c. References ASSERT, ASSERTFLAG_COMPLETEATPASSIVE, ASSERTFLAG_DEFERCOMPLETION, ASSERTFLAG_FORCEPENDING, _IOV_SESSION_DATA::AssertFlags, _IOV_SESSION_DATA::BestVisibleIrp, _IRP::CurrentLocation, ExAllocatePoolWithTag, FALSE, _IOV_REQUEST_PACKET::Flags, _IOV_REQUEST_PACKET::HeadPacket, IOV_SESSION_DATA, IOV_STACK_LOCATION, IovpSessionDataAttachSurrogate(), IovpSessionDataDeterminePolicy(), IovpTrackingFlags, _IOV_SESSION_DATA::IovRequestPacket, NonPagedPool, NULL, PIOV_REQUEST_PACKET, _IOV_REQUEST_PACKET::pIovSessionData, POOL_TAG_SESSION_DATA, _IOV_REQUEST_PACKET::SessionHead, _IOV_SESSION_DATA::SessionLink, _IRP::StackCount, _IOV_REQUEST_PACKET::TopStackLocation, _IOV_REQUEST_PACKET::TrackedIrp, TRACKFLAG_ACTIVE, TRACKFLAG_PASSED_FAILURE, TRACKFLAG_QUEUED_INTERNALLY, TRACKFLAG_RELEASED, TRACKFLAG_SRB_MUNGED, TRACKFLAG_SWAPPED_BACK, and TRACKIRP_DBGPRINT. Referenced by IovpCallDriver1(). : This routine creates tracking data for a new IRP. It must be called on the thread the IRP was originally sent down... Arguments: Irp - Irp to track. Return Value: iovPacket block, NULL if no memory. --*/ { PIRP irp, surrogateIrp; PIOV_SESSION_DATA iovSessionData; PIOV_REQUEST_PACKET headPacket; ULONG sessionDataSize; BOOLEAN trackable, useSurrogateIrp; *SurrogateSpawned = FALSE; headPacket = (*IovPacketPointer)->HeadPacket; ASSERT(headPacket == (*IovPacketPointer)); irp = headPacket->TrackedIrp; // // Check the IRP appropriately // IovpSessionDataDeterminePolicy( headPacket, DeviceObject, &trackable, &useSurrogateIrp ); if (!trackable) { return NULL; } // // One extra stack location is allocated as the "zero'th" is used to // simplify some logic... // sessionDataSize = sizeof(IOV_SESSION_DATA)+ irp->StackCount*sizeof(IOV_STACK_LOCATION); iovSessionData = ExAllocatePoolWithTag( NonPagedPool, sessionDataSize, POOL_TAG_SESSION_DATA ); if (iovSessionData == NULL) { return NULL; } RtlZeroMemory(iovSessionData, sessionDataSize); iovSessionData->AssertFlags = IovpTrackingFlags; iovSessionData->IovRequestPacket = headPacket; InsertHeadList(&headPacket->SessionHead, &iovSessionData->SessionLink); if ((iovSessionData->AssertFlags&ASSERTFLAG_COMPLETEATPASSIVE) || (iovSessionData->AssertFlags&ASSERTFLAG_DEFERCOMPLETION)) { iovSessionData->AssertFlags |= ASSERTFLAG_FORCEPENDING; } headPacket->pIovSessionData = iovSessionData; headPacket->TopStackLocation = irp->CurrentLocation; headPacket->Flags |= TRACKFLAG_ACTIVE; headPacket->Flags &=~ ( TRACKFLAG_QUEUED_INTERNALLY| TRACKFLAG_RELEASED| TRACKFLAG_SRB_MUNGED| TRACKFLAG_SWAPPED_BACK| TRACKFLAG_PASSED_FAILURE ); iovSessionData->BestVisibleIrp = irp; if (useSurrogateIrp) { // // We will track the IRP using a surrogate. // *SurrogateSpawned = IovpSessionDataAttachSurrogate( IovPacketPointer, iovSessionData ); } TRACKIRP_DBGPRINT(( " SSN CREATE(%x)->%x\n", headPacket, iovSessionData ), 3) ; return iovSessionData; }

VOID FASTCALL IovpSessionDataDereference (  IN PIOV_SESSION_DATA  IovSessionData  )

Definition at line 152 of file sessnirp.c. References ASSERT, ASSERT_SPINLOCK_HELD, ExFreePool(), _IOV_REQUEST_PACKET::HeadPacket, IovpTrackingDataDereference(), IOVREFTYPE_PACKET, _IOV_REQUEST_PACKET::IrpLock, _IOV_REQUEST_PACKET::pIovSessionData, _IOV_REQUEST_PACKET::PointerCount, _IOV_REQUEST_PACKET::ReferenceCount, and TRACKIRP_DBGPRINT. Referenced by IovpCallDriver2(), IovpCompleteRequest2(), IovpCompleteRequest5(), and IovpSwapSurrogateIrp(). { PIOV_REQUEST_PACKET iovPacket, headPacket; iovPacket = IovSessionData->IovRequestPacket; headPacket = iovPacket->HeadPacket; ASSERT_SPINLOCK_HELD(&headPacket->IrpLock); ASSERT_SPINLOCK_HELD(&iovPacket->IrpLock); ASSERT(IovSessionData->SessionRefCount > 0); ASSERT(headPacket->ReferenceCount > 0); ASSERT(iovPacket->ReferenceCount >= 0); TRACKIRP_DBGPRINT(( " SSN DEREF(%x) %x--\n", IovSessionData, IovSessionData->SessionRefCount ), 3) ; IovSessionData->SessionRefCount--; if (!IovSessionData->SessionRefCount) { ASSERT(headPacket->pIovSessionData != IovSessionData); ASSERT(iovPacket->ReferenceCount > iovPacket->PointerCount); //ASSERT(IsListEmpty(&IovSessionData->SessionLink)); RemoveEntryList(&IovSessionData->SessionLink); InitializeListHead(&IovSessionData->SessionLink); IovpTrackingDataDereference(iovPacket, IOVREFTYPE_PACKET); ExFreePool(IovSessionData); } }

VOID IovpSessionDataDeterminePolicy (  IN PIOV_REQUEST_PACKET  IovRequestPacket, IN PDEVICE_OBJECT  DeviceObject, OUT PBOOLEAN  Trackable, OUT PBOOLEAN  UseSurrogateIrp )

Definition at line 240 of file sessnirp.c. References ASSERTFLAG_POLICEIRPS, ASSERTFLAG_SMASH_SRBS, ASSERTFLAG_SURROGATE, ASSERTFLAG_TRACKIRPS, FALSE, HACKFLAG_FOR_MUP, IoGetNextIrpStackLocation, IovpHackFlags, IovpIsInterestingStack(), IovpTrackingFlags, IRP_MJ_CREATE, IRP_MJ_SCSI, and _IO_STACK_LOCATION::MajorFunction. Referenced by IovpSessionDataCreate(). : This routine is called by IovpCallDriver1 to determine which IRPs should be tracked and how that tracking should be done. Arguments: ADRIAO BUGBUG 12/31/1998 - Fill this out. Return Value: None. --*/ { PIO_STACK_LOCATION irpSp; PIRP irp; irp = IovRequestPacket->TrackedIrp; if (!(IovpTrackingFlags&ASSERTFLAG_TRACKIRPS)) { // // No IRPs are to be tracked. Exit now. // *Trackable = FALSE; return; } // // Determine whether we are to monitor this IRP. If we are going to test // any one driver in a stack, then we must unfortunately monitor the IRP's // progress through the *entire* stack. Thus our granularity here is stack // based, not device based! We will compensate for this somewhat in the // driver check code, which will attempt to ignore asserts from those // "non-targetted" drivers who happen to have screwed up in our stack... // *Trackable = IovpIsInterestingStack(DeviceObject); irpSp = IoGetNextIrpStackLocation( irp ); if (IovpTrackingFlags&ASSERTFLAG_POLICEIRPS) { *UseSurrogateIrp = ((IovpTrackingFlags&ASSERTFLAG_SURROGATE)!=0) ; *UseSurrogateIrp &= ((irpSp->MajorFunction != IRP_MJ_SCSI) || ((IovpTrackingFlags&ASSERTFLAG_SMASH_SRBS)!=0)) ; #ifdef HACKHACKS_ENABLED // // ADRIAO HACKHACK #05 05/30/98 - // We don't surrogate creates right now because MUP touches IRPs // after they are completed. // if (IovpHackFlags&HACKFLAG_FOR_MUP) { *UseSurrogateIrp &= (irpSp->MajorFunction != IRP_MJ_CREATE) ; } #endif } else { *UseSurrogateIrp = FALSE; } }

VOID FASTCALL IovpSessionDataFinalizeSurrogate (  IN PIOV_SESSION_DATA  IovSessionData, IN OUT PIOV_REQUEST_PACKET  IovPacket, IN PIRP  Irp )

Definition at line 523 of file sessnirp.c. References _IRP::AllocationFlags, _IRP::ApcEnvironment, ASSERT, _IRP::AssociatedIrp, _IRP::Cancel, _IOV_REQUEST_PACKET::Flags, _IRP::Flags, IoMarkIrpPending, _IRP::IoStatus, IovpProtectedIrpFree(), IovpProtectedIrpMakeUntouchable(), IovpTrackingDataDereference(), IovpTrackingDataGetCurrentSessionData(), IOVREFTYPE_POINTER, IRP_DEALLOCATE_BUFFER, IRP_DIAG_HAS_SURROGATE, IRP_DIAG_IS_SURROGATE, IRPFLAG_EXAMINE_MASK, _IRP::MdlAddress, NTSTATUS(), NULL, _IRP::Overlay, _IRP::PendingReturned, _IRP::RequestorMode, _IRP::StackCount, _IRP::Tail, _IOV_REQUEST_PACKET::TrackedIrp, TRACKFLAG_SURROGATE, TRUE, _IRP::Type, and _IRP::UserBuffer. Referenced by IovpSwapSurrogateIrp(). 00530 : 00531 00532 This routine removes the flags from both the real and 00533 surrogate IRP and records the final IRP settings. Finally, 00534 the surrogate IRP is made "untouchable" (decommitted). 00535 00536 Arguments: 00537 00538 iovPacket - Pointer to the IRP tracking data. 00539 00540 Return Value: 00541 00542 None. 00543 --*/ 00544 { 00545 PIOV_REQUEST_PACKET iovPrevPacket; 00546 NTSTATUS status, lockedStatus; 00547 ULONG nonInterestingFlags; 00548 PIO_STACK_LOCATION irpSp; 00549 PVOID restoreHandle; 00550 PIRP irp; 00551 00552 ASSERT(IovPacket->Flags&TRACKFLAG_SURROGATE); 00553 00554 ASSERT(IovpTrackingDataGetCurrentSessionData(IovPacket) == IovSessionData); 00555 00556 // 00557 // It's a surrogate, do as appropriate. 00558 // 00559 ASSERT(IovPacket->TopStackLocation == SurrogateIrp->CurrentLocation+1) ; 00560 00561 iovPrevPacket = CONTAINING_RECORD( 00562 IovPacket->SurrogateLink.Blink, 00563 IOV_REQUEST_PACKET, 00564 SurrogateLink 00565 ); 00566 00567 irp = iovPrevPacket->TrackedIrp; 00568 00569 // 00570 // Carry the pending bit over. 00571 // 00572 if (SurrogateIrp->PendingReturned) { 00573 IoMarkIrpPending(irp); 00574 } 00575 00576 nonInterestingFlags = ( 00577 IRPFLAG_EXAMINE_MASK | 00578 IRP_DIAG_IS_SURROGATE| 00579 IRP_DIAG_HAS_SURROGATE 00580 ); 00581 00582 // 00583 // Wipe the flags nice and clean 00584 // 00585 SurrogateIrp->Flags &=~ IRP_DIAG_IS_SURROGATE; 00586 irp->Flags &=~ IRP_DIAG_HAS_SURROGATE; 00587 00588 // 00589 // ASSERT portions of the IRP header have not changed. 00590 // 00591 ASSERT(irp->StackCount == SurrogateIrp->StackCount); // Later to be removed 00592 00593 ASSERT(irp->Type == SurrogateIrp->Type); 00594 ASSERT(irp->RequestorMode == SurrogateIrp->RequestorMode); 00595 ASSERT(irp->ApcEnvironment == SurrogateIrp->ApcEnvironment); 00596 ASSERT(irp->AllocationFlags == SurrogateIrp->AllocationFlags); 00597 ASSERT(irp->UserBuffer == SurrogateIrp->UserBuffer); 00598 ASSERT(irp->Tail.Overlay.Thread == SurrogateIrp->Tail.Overlay.Thread); 00599 00600 ASSERT( 00601 irp->Overlay.AsynchronousParameters.UserApcRoutine == 00602 SurrogateIrp->Overlay.AsynchronousParameters.UserApcRoutine 00603 ); 00604 00605 ASSERT( 00606 irp->Overlay.AsynchronousParameters.UserApcContext == 00607 SurrogateIrp->Overlay.AsynchronousParameters.UserApcContext 00608 ); 00609 00610 ASSERT( 00611 irp->Tail.Overlay.OriginalFileObject == 00612 SurrogateIrp->Tail.Overlay.OriginalFileObject 00613 ); 00614 00615 ASSERT( 00616 irp->Tail.Overlay.AuxiliaryBuffer == 00617 SurrogateIrp->Tail.Overlay.AuxiliaryBuffer 00618 ); 00619 00620 /* 00621 ASSERT( 00622 irp->AssociatedIrp.SystemBuffer == 00623 SurrogateIrp->AssociatedIrp.SystemBuffer 00624 ); 00625 00626 ASSERT( 00627 (irp->Flags & ~nonInterestingFlags) == 00628 (SurrogateIrp->Flags & ~nonInterestingFlags) 00629 ); 00630 00631 ASSERT(irp->MdlAddress == SurrogateIrp->MdlAddress); 00632 */ 00633 // 00634 // ADRIAO BUGBUG 02/28/1999 - 00635 // How do these change as an IRP progresses? 00636 // 00637 irp->Flags |= SurrogateIrp->Flags; 00638 irp->MdlAddress = SurrogateIrp->MdlAddress; 00639 irp->AssociatedIrp.SystemBuffer = SurrogateIrp->AssociatedIrp.SystemBuffer; 00640 00641 if ((irp->Flags&IRP_DEALLOCATE_BUFFER)&& 00642 (irp->AssociatedIrp.SystemBuffer == NULL)) { 00643 00644 irp->Flags &=~ IRP_DEALLOCATE_BUFFER; 00645 } 00646 00647 // 00648 // Copy the salient fields back. We only need to touch certain areas of the 00649 // header. 00650 // 00651 irp->IoStatus = SurrogateIrp->IoStatus; 00652 irp->PendingReturned = SurrogateIrp->PendingReturned; 00653 irp->Cancel = SurrogateIrp->Cancel; 00654 00655 iovPrevPacket->Flags &=~ TRACKFLAG_HAS_SURROGATE; 00656 00657 // 00658 // Record data from it and make the system fault if the IRP is touched 00659 // after this completion routine. 00660 // 00661 IovSessionData->BestVisibleIrp = irp; 00662 00663 IovpTrackingDataDereference(iovPrevPacket, IOVREFTYPE_POINTER); 00664 00665 ASSERT(IovPacket->PointerCount == 0); 00666 00667 restoreHandle = IovpProtectedIrpMakeUntouchable(SurrogateIrp, TRUE); 00668 IovpProtectedIrpFree(SurrogateIrp, &restoreHandle); 00669 } #endif // NO_SPECIAL_IRP

VOID FASTCALL IovpSessionDataReference (  IN PIOV_SESSION_DATA  IovSessionData  )

Definition at line 190 of file sessnirp.c. References ASSERT, ASSERT_SPINLOCK_HELD, _IOV_REQUEST_PACKET::HeadPacket, IovpTrackingDataReference(), IOVREFTYPE_PACKET, _IOV_REQUEST_PACKET::IrpLock, _IOV_REQUEST_PACKET::ReferenceCount, and TRACKIRP_DBGPRINT. Referenced by IovpCallDriver1(), and IovpCompleteRequest2(). { PIOV_REQUEST_PACKET iovPacket, headPacket; iovPacket = IovSessionData->IovRequestPacket; headPacket = iovPacket->HeadPacket; ASSERT_SPINLOCK_HELD(&headPacket->IrpLock); ASSERT_SPINLOCK_HELD(&iovPacket->IrpLock); ASSERT(IovSessionData->SessionRefCount >= 0); ASSERT(headPacket->ReferenceCount >= 0); ASSERT(iovPacket->ReferenceCount >= 0); TRACKIRP_DBGPRINT(( " SSN REF(%x) %x++\n", IovSessionData, IovSessionData->SessionRefCount ), 3) ; if (!IovSessionData->SessionRefCount) { IovpTrackingDataReference(iovPacket, IOVREFTYPE_PACKET); } IovSessionData->SessionRefCount++; }

---