pinsup.c File Reference

#include "cc.h"

Go to the source code of this file.

Defines
#define	me   0x00000008
Functions
POBCB	CcAllocateObcb (IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN PBCB FirstBcb)
BOOLEAN	CcMapData (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, OUT PVOID *Bcb, OUT PVOID *Buffer)
BOOLEAN	CcPinMappedData (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG Flags, IN OUT PVOID *Bcb)
BOOLEAN	CcPinRead (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG Flags, OUT PVOID *Bcb, OUT PVOID *Buffer)
BOOLEAN	CcPreparePinWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Zero, IN ULONG Flags, OUT PVOID *Bcb, OUT PVOID *Buffer)
VOID	CcUnpinData (IN PVOID Bcb)
VOID	CcSetBcbOwnerPointer (IN PVOID Bcb, IN PVOID OwnerPointer)
VOID	CcUnpinDataForThread (IN PVOID Bcb, IN ERESOURCE_THREAD ResourceThreadId)

---

Define Documentation

#define me   0x00000008

Definition at line 28 of file pinsup.c.

---

Function Documentation

POBCB CcAllocateObcb (  IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, IN PBCB  FirstBcb )

Definition at line 1230 of file pinsup.c. References _OBCB::Bcbs, _OBCB::ByteLength, _BCB::ByteLength, CACHE_NTC_OBCB, _OBCB::FileOffset, _BCB::FileOffset, FsRtlAllocatePoolWithTag, _OBCB::NodeByteSize, _OBCB::NodeTypeCode, NonPagedPool, OBCB, PAGE_SIZE, and USHORT. Referenced by CcPinMappedData(), CcPinRead(), and CcPreparePinWrite(). 01238 : 01239 01240 This routine is called by the various pinning routines to allocate and 01241 initialize an overlap Bcb. 01242 01243 Arguments: 01244 01245 FileOffset - Starting file offset for the Obcb (An Obcb starts with a 01246 public structure, which someone could use) 01247 01248 Length - Length of the range covered by the Obcb 01249 01250 FirstBcb - First Bcb already created, which only covers the start of 01251 the desired range (low order bit may be set to indicate ReadOnly) 01252 01253 Return Value: 01254 01255 Pointer to the allocated Obcb 01256 01257 --*/ 01258 01259 { 01260 ULONG LengthToAllocate; 01261 POBCB Obcb; 01262 PBCB Bcb = (PBCB)((ULONG_PTR)FirstBcb & ~1); 01263 01264 // 01265 // Allocate according to the worst case, assuming that we 01266 // will need as many additional Bcbs as there are pages 01267 // remaining. Also throw in one more pointer to guarantee 01268 // users of the OBCB can always terminate on NULL. 01269 // 01270 // We remove fron consideration the range described by the 01271 // first Bcb (note that the range of the Obcb is not strictly 01272 // starting at the first Bcb) and add in locations for the first 01273 // bcb and the null. 01274 // 01275 01276 LengthToAllocate = FIELD_OFFSET(OBCB, Bcbs) + (2 * sizeof(PBCB)) + 01277 ((Length - 01278 (Bcb->ByteLength - 01279 (FileOffset->HighPart? 01280 (ULONG)(FileOffset->QuadPart - Bcb->FileOffset.QuadPart) : 01281 FileOffset->LowPart - Bcb->FileOffset.LowPart)) + 01282 PAGE_SIZE - 1) / PAGE_SIZE) * sizeof(PBCB); 01283 01284 Obcb = FsRtlAllocatePoolWithTag( NonPagedPool, LengthToAllocate, 'bOcC' ); 01285 RtlZeroMemory( Obcb, LengthToAllocate ); 01286 Obcb->NodeTypeCode = CACHE_NTC_OBCB; 01287 Obcb->NodeByteSize = (USHORT)LengthToAllocate; 01288 Obcb->ByteLength = Length; 01289 Obcb->FileOffset = *FileOffset; 01290 Obcb->Bcbs[0] = FirstBcb; 01291 01292 return Obcb; 01293 } }

BOOLEAN CcMapData (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, IN BOOLEAN  Wait, OUT PVOID *  Bcb, OUT PVOID *  Buffer )

Definition at line 52 of file pinsup.c. References ASSERT, Buffer, CcBcbSpinLock, CcGetVirtualAddress(), CcMapDataNoWait, CcMapDataNoWaitMiss, CcMapDataWait, CcMapDataWaitMiss, CcMissCounter, CcPinFileData(), CcThrowAway, CcUnpinFileData(), COMPUTE_PAGES_SPANNED, DebugTrace, FALSE, me, MmResetPageFaultReadAhead, MmSavePageFaultReadAhead, MmSetPageFaultReadAhead, NULL, PAGE_SIZE, PsGetCurrentThread, TRUE, and UNPIN. Referenced by LfsFlushLfcb(), LfsPinOrMapData(), UdfLookupDirEntryPostProcessing(), UdfLookupInitialDirEntry(), UdfLookupPsnOfExtent(), UdfMapMetadataView(), and UdfUpdateVcbPhase0(). : This routine attempts to map the specified file data in the cache. A pointer is returned to the desired data in the cache. If the caller does not want to block on this call, then Wait should be supplied as FALSE. If Wait was supplied as FALSE and it is currently impossible to supply the requested data without blocking, then this routine will return FALSE. However, if the data is immediately accessible in the cache and no blocking is required, this routine returns TRUE with a pointer to the data. Note that a call to this routine with Wait supplied as TRUE is considerably faster than a call with Wait supplies as FALSE, because in the Wait TRUE case we only have to make sure the data is mapped in order to return. It is illegal to modify data that is only mapped, and can in fact lead to serious problems. It is impossible to check for this in all cases, however CcSetDirtyPinnedData may implement some Assertions to check for this. If the caller wishes to modify data that it has only mapped, then it must *first* call CcPinMappedData. In any case, the caller MUST subsequently call CcUnpinData. Naturally if CcPinRead or CcPreparePinWrite were called multiple times for the same data, CcUnpinData must be called the same number of times. The returned Buffer pointer is valid until the data is unpinned, at which point it is invalid to use the pointer further. This buffer pointer will remain valid if CcPinMappedData is called. Note that under some circumstances (like Wait supplied as FALSE or more than a page is requested), this routine may actually pin the data, however it is not necessary, and in fact not correct, for the caller to be concerned about this. Arguments: FileObject - Pointer to the file object for a file which was opened with NO_INTERMEDIATE_BUFFERING clear, i.e., for which CcInitializeCacheMap was called by the file system. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. Wait - FALSE if caller may not block, TRUE otherwise (see description above) Bcb - On the first call this returns a pointer to a Bcb parameter which must be supplied as input on all subsequent calls, for this buffer Buffer - Returns pointer to desired data, valid until the buffer is unpinned or freed. This pointer will remain valid if CcPinMappedData is called. Return Value: FALSE - if Wait was supplied as FALSE and the data was not delivered TRUE - if the data is being delivered --*/ { PSHARED_CACHE_MAP SharedCacheMap; LARGE_INTEGER BeyondLastByte; ULONG ReceivedLength; ULONG SavedState; volatile UCHAR ch; ULONG PageCount = COMPUTE_PAGES_SPANNED((ULongToPtr(FileOffset->LowPart)), Length); PETHREAD Thread = PsGetCurrentThread(); DebugTrace(+1, me, "CcMapData\n", 0 ); MmSavePageFaultReadAhead( Thread, &SavedState ); // // Increment performance counters // if (Wait) { CcMapDataWait += 1; // // Initialize the indirect pointer to our miss counter. // CcMissCounter = &CcMapDataWaitMiss; } else { CcMapDataNoWait += 1; } // // Get pointer to SharedCacheMap. // SharedCacheMap = *(PSHARED_CACHE_MAP *)((PCHAR)FileObject->SectionObjectPointer + sizeof(PVOID)); // // Call local routine to Map or Access the file data. If we cannot map // the data because of a Wait condition, return FALSE. // if (Wait) { *Buffer = CcGetVirtualAddress( SharedCacheMap, *FileOffset, (PVACB *)Bcb, &ReceivedLength ); ASSERT( ReceivedLength >= Length ); } else if (!CcPinFileData( FileObject, FileOffset, Length, TRUE, FALSE, Wait, (PBCB *)Bcb, Buffer, &BeyondLastByte )) { DebugTrace(-1, me, "CcMapData -> FALSE\n", 0 ); CcMapDataNoWaitMiss += 1; return FALSE; } else { ASSERT( (BeyondLastByte.QuadPart - FileOffset->QuadPart) >= Length ); #if LIST_DBG { KIRQL OldIrql; PBCB BcbTemp = (PBCB)*Bcb; ExAcquireSpinLock( &CcBcbSpinLock, &OldIrql ); if (BcbTemp->CcBcbLinks.Flink == NULL) { InsertTailList( &CcBcbList, &BcbTemp->CcBcbLinks ); CcBcbCount += 1; ExReleaseSpinLock( &CcBcbSpinLock, OldIrql ); SetCallersAddress( BcbTemp ); } else { ExReleaseSpinLock( &CcBcbSpinLock, OldIrql ); } } #endif } // // Now let's just sit here and take the miss(es) like a man (and count them). // try { // // Loop to touch each page // BeyondLastByte.LowPart = 0; while (PageCount != 0) { MmSetPageFaultReadAhead( Thread, PageCount - 1 ); ch = *((volatile UCHAR *)(*Buffer) + BeyondLastByte.LowPart); BeyondLastByte.LowPart += PAGE_SIZE; PageCount -= 1; } } finally { MmResetPageFaultReadAhead( Thread, SavedState ); if (AbnormalTermination() && (*Bcb != NULL)) { CcUnpinFileData( (PBCB)*Bcb, TRUE, UNPIN ); *Bcb = NULL; } } CcMissCounter = &CcThrowAway; // // Increment the pointer as a reminder that it is read only. // *(PCHAR *)Bcb += 1; DebugTrace(-1, me, "CcMapData -> TRUE\n", 0 ); return TRUE; }

BOOLEAN CcPinMappedData (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, IN ULONG  Flags, IN OUT PVOID *  Bcb )

Definition at line 271 of file pinsup.c. References BooleanFlagOn, Buffer, CACHE_NTC_BCB, CcAllocateObcb(), CcBcbSpinLock, CcFreeVirtualAddress(), CcPinFileData(), CcPinMappedDataCount, CcUnpinData(), DebugTrace, ExAcquireSharedStarveExclusive(), FALSE, FlagOn, _SHARED_CACHE_MAP::Flags, me, MODIFIED_WRITE_DISABLED, NULL, PIN_WAIT, Resource, TRUE, and try_return. : This routine attempts to pin data that was previously only mapped. If the routine determines that in fact it was necessary to actually pin the data when CcMapData was called, then this routine does not have to do anything. If the caller does not want to block on this call, then Wait should be supplied as FALSE. If Wait was supplied as FALSE and it is currently impossible to supply the requested data without blocking, then this routine will return FALSE. However, if the data is immediately accessible in the cache and no blocking is required, this routine returns TRUE with a pointer to the data. If the data is not returned in the first call, the caller may request the data later with Wait = TRUE. It is not required that the caller request the data later. If the caller subsequently modifies the data, it should call CcSetDirtyPinnedData. In any case, the caller MUST subsequently call CcUnpinData. Naturally if CcPinRead or CcPreparePinWrite were called multiple times for the same data, CcUnpinData must be called the same number of times. Note there are no performance counters in this routine, as the misses will almost always occur on the map above, and there will seldom be a miss on this conversion. Arguments: FileObject - Pointer to the file object for a file which was opened with NO_INTERMEDIATE_BUFFERING clear, i.e., for which CcInitializeCacheMap was called by the file system. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. Flags - (PIN_WAIT, PIN_EXCLUSIVE, PIN_NO_READ, etc. as defined in cache.h) If the caller specifies PIN_NO_READ and PIN_EXCLUSIVE, then he must guarantee that no one else will be attempting to map the view, if he wants to guarantee that the Bcb is not mapped (view may be purged). If the caller specifies PIN_NO_READ without PIN_EXCLUSIVE, the data may or may not be mapped in the return Bcb. Bcb - On the first call this returns a pointer to a Bcb parameter which must be supplied as input on all subsequent calls, for this buffer Return Value: FALSE - if Wait was not set and the data was not delivered TRUE - if the data is being delivered --*/ { PVOID Buffer; LARGE_INTEGER BeyondLastByte; PSHARED_CACHE_MAP SharedCacheMap; LARGE_INTEGER LocalFileOffset = *FileOffset; POBCB MyBcb = NULL; PBCB *CurrentBcbPtr = (PBCB *)&MyBcb; BOOLEAN Result = FALSE; DebugTrace(+1, me, "CcPinMappedData\n", 0 ); // // If the Bcb is no longer ReadOnly, then just return. // if ((*(PULONG)Bcb & 1) == 0) { return TRUE; } // // Remove the Read Only flag // *(PCHAR *)Bcb -= 1; // // Get pointer to SharedCacheMap. // SharedCacheMap = *(PSHARED_CACHE_MAP *)((PCHAR)FileObject->SectionObjectPointer + sizeof(PVOID)); // // We only count the calls to this routine, since they are almost guaranteed // to be hits. // CcPinMappedDataCount += 1; // // Guarantee we will put the flag back if required. // try { if (((PBCB)*Bcb)->NodeTypeCode != CACHE_NTC_BCB) { // // Form loop to handle occassional overlapped Bcb case. // do { // // If we have already been through the loop, then adjust // our file offset and length from the last time. // if (MyBcb != NULL) { // // If this is the second time through the loop, then it is time // to handle the overlap case and allocate an OBCB. // if (CurrentBcbPtr == (PBCB *)&MyBcb) { MyBcb = CcAllocateObcb( FileOffset, Length, (PBCB)MyBcb ); // // Set CurrentBcbPtr to point at the first entry in // the vector (which is already filled in), before // advancing it below. // CurrentBcbPtr = &MyBcb->Bcbs[0]; } Length -= (ULONG)(BeyondLastByte.QuadPart - LocalFileOffset.QuadPart); LocalFileOffset.QuadPart = BeyondLastByte.QuadPart; CurrentBcbPtr += 1; } // // Call local routine to Map or Access the file data. If we cannot map // the data because of a Wait condition, return FALSE. // if (!CcPinFileData( FileObject, &LocalFileOffset, Length, (BOOLEAN)!FlagOn(SharedCacheMap->Flags, MODIFIED_WRITE_DISABLED), FALSE, Flags, CurrentBcbPtr, &Buffer, &BeyondLastByte )) { try_return( Result = FALSE ); } // // Continue looping if we did not get everything. // } while((BeyondLastByte.QuadPart - LocalFileOffset.QuadPart) < Length); // // Free the Vacb before going on. // CcFreeVirtualAddress( (PVACB)*Bcb ); *Bcb = MyBcb; // // Debug routines used to insert and remove Bcbs from the global list // #if LIST_DBG { KIRQL OldIrql; PBCB BcbTemp = (PBCB)*Bcb; ExAcquireSpinLock( &CcBcbSpinLock, &OldIrql ); if (BcbTemp->CcBcbLinks.Flink == NULL) { InsertTailList( &CcBcbList, &BcbTemp->CcBcbLinks ); CcBcbCount += 1; ExReleaseSpinLock( &CcBcbSpinLock, OldIrql ); SetCallersAddress( BcbTemp ); } else { ExReleaseSpinLock( &CcBcbSpinLock, OldIrql ); } } #endif } // // If he really has a Bcb, all we have to do is acquire it shared since he is // no longer ReadOnly. // else { if (!ExAcquireSharedStarveExclusive( &((PBCB)*Bcb)->Resource, BooleanFlagOn(Flags, PIN_WAIT))) { try_return( Result = FALSE ); } } Result = TRUE; try_exit: NOTHING; } finally { if (!Result) { // // Put the Read Only flag back // *(PCHAR *)Bcb += 1; // // We may have gotten partway through // if (MyBcb != NULL) { CcUnpinData( MyBcb ); } } DebugTrace(-1, me, "CcPinMappedData -> %02lx\n", Result ); } return Result; }

BOOLEAN CcPinRead (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, IN ULONG  Flags, OUT PVOID *  Bcb, OUT PVOID *  Buffer )

Definition at line 524 of file pinsup.c. References Buffer, CcAllocateObcb(), CcBcbSpinLock, CcMissCounter, CcPinFileData(), CcPinReadNoWait, CcPinReadNoWaitMiss, CcPinReadWait, CcPinReadWaitMiss, CcThrowAway, CcUnpinData(), DebugTrace, FALSE, FlagOn, _SHARED_CACHE_MAP::Flags, me, MODIFIED_WRITE_DISABLED, NULL, PIN_WAIT, TRUE, and try_return. Referenced by LfsPinOrMapData(). : This routine attempts to pin the specified file data in the cache. A pointer is returned to the desired data in the cache. This routine is intended for File System support and is not intended to be called from Dpc level. If the caller does not want to block on this call, then Wait should be supplied as FALSE. If Wait was supplied as FALSE and it is currently impossible to supply the requested data without blocking, then this routine will return FALSE. However, if the data is immediately accessible in the cache and no blocking is required, this routine returns TRUE with a pointer to the data. If the data is not returned in the first call, the caller may request the data later with Wait = TRUE. It is not required that the caller request the data later. If the caller subsequently modifies the data, it should call CcSetDirtyPinnedData. In any case, the caller MUST subsequently call CcUnpinData. Naturally if CcPinRead or CcPreparePinWrite were called multiple times for the same data, CcUnpinData must be called the same number of times. The returned Buffer pointer is valid until the data is unpinned, at which point it is invalid to use the pointer further. Arguments: FileObject - Pointer to the file object for a file which was opened with NO_INTERMEDIATE_BUFFERING clear, i.e., for which CcInitializeCacheMap was called by the file system. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. Flags - (PIN_WAIT, PIN_EXCLUSIVE, PIN_NO_READ, etc. as defined in cache.h) If the caller specifies PIN_NO_READ and PIN_EXCLUSIVE, then he must guarantee that no one else will be attempting to map the view, if he wants to guarantee that the Bcb is not mapped (view may be purged). If the caller specifies PIN_NO_READ without PIN_EXCLUSIVE, the data may or may not be mapped in the return Bcb. Bcb - On the first call this returns a pointer to a Bcb parameter which must be supplied as input on all subsequent calls, for this buffer Buffer - Returns pointer to desired data, valid until the buffer is unpinned or freed. Return Value: FALSE - if Wait was not set and the data was not delivered TRUE - if the data is being delivered --*/ { PSHARED_CACHE_MAP SharedCacheMap; PVOID LocalBuffer; LARGE_INTEGER BeyondLastByte; LARGE_INTEGER LocalFileOffset = *FileOffset; POBCB MyBcb = NULL; PBCB *CurrentBcbPtr = (PBCB *)&MyBcb; BOOLEAN Result = FALSE; DebugTrace(+1, me, "CcPinRead\n", 0 ); // // Increment performance counters // if (FlagOn(Flags, PIN_WAIT)) { CcPinReadWait += 1; // // Initialize the indirect pointer to our miss counter. // CcMissCounter = &CcPinReadWaitMiss; } else { CcPinReadNoWait += 1; } // // Get pointer to SharedCacheMap. // SharedCacheMap = *(PSHARED_CACHE_MAP *)((PCHAR)FileObject->SectionObjectPointer + sizeof(PVOID)); try { // // Form loop to handle occassional overlapped Bcb case. // do { // // If we have already been through the loop, then adjust // our file offset and length from the last time. // if (MyBcb != NULL) { // // If this is the second time through the loop, then it is time // to handle the overlap case and allocate an OBCB. // if (CurrentBcbPtr == (PBCB *)&MyBcb) { MyBcb = CcAllocateObcb( FileOffset, Length, (PBCB)MyBcb ); // // Set CurrentBcbPtr to point at the first entry in // the vector (which is already filled in), before // advancing it below. // CurrentBcbPtr = &MyBcb->Bcbs[0]; // // Also on second time through, return starting Buffer // *Buffer = LocalBuffer; } Length -= (ULONG)(BeyondLastByte.QuadPart - LocalFileOffset.QuadPart); LocalFileOffset.QuadPart = BeyondLastByte.QuadPart; CurrentBcbPtr += 1; } // // Call local routine to Map or Access the file data. If we cannot map // the data because of a Wait condition, return FALSE. // if (!CcPinFileData( FileObject, &LocalFileOffset, Length, (BOOLEAN)!FlagOn(SharedCacheMap->Flags, MODIFIED_WRITE_DISABLED), FALSE, Flags, CurrentBcbPtr, &LocalBuffer, &BeyondLastByte )) { CcPinReadNoWaitMiss += 1; try_return( Result = FALSE ); } // // Continue looping if we did not get everything. // } while((BeyondLastByte.QuadPart - LocalFileOffset.QuadPart) < Length); *Bcb = MyBcb; // // Debug routines used to insert and remove Bcbs from the global list // #if LIST_DBG { KIRQL OldIrql; PBCB BcbTemp = (PBCB)*Bcb; ExAcquireSpinLock( &CcBcbSpinLock, &OldIrql ); if (BcbTemp->CcBcbLinks.Flink == NULL) { InsertTailList( &CcBcbList, &BcbTemp->CcBcbLinks ); CcBcbCount += 1; ExReleaseSpinLock( &CcBcbSpinLock, OldIrql ); SetCallersAddress( BcbTemp ); } else { ExReleaseSpinLock( &CcBcbSpinLock, OldIrql ); } } #endif // // In the normal (nonoverlapping) case we return the // correct buffer address here. // if (CurrentBcbPtr == (PBCB *)&MyBcb) { *Buffer = LocalBuffer; } Result = TRUE; try_exit: NOTHING; } finally { CcMissCounter = &CcThrowAway; if (!Result) { // // We may have gotten partway through // if (MyBcb != NULL) { CcUnpinData( MyBcb ); } } DebugTrace(-1, me, "CcPinRead -> %02lx\n", Result ); } return Result; }

BOOLEAN CcPreparePinWrite (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, IN BOOLEAN  Zero, IN ULONG  Flags, OUT PVOID *  Bcb, OUT PVOID *  Buffer )

Definition at line 767 of file pinsup.c. References Buffer, CcAllocateObcb(), CcBcbSpinLock, CcMissCounter, CcPinFileData(), CcSetDirtyPinnedData(), CcThrowAway, CcUnpinData(), DebugTrace, FALSE, me, NULL, TRUE, try_return, and Zero. : This routine attempts to lock the specified file data in the cache and return a pointer to it along with the correct I/O status. Pages to be completely overwritten may be satisfied with emtpy pages. If not all of the pages can be prepared, and Wait was supplied as FALSE, then this routine will return FALSE, and its outputs will be meaningless. The caller may request the data later with Wait = TRUE. However, it is not required that the caller request the data later. If Wait is supplied as TRUE, and all of the pages can be prepared without blocking, this call will return TRUE immediately. Otherwise, this call will block until all of the pages can be prepared, and then return TRUE. When this call returns with TRUE, the caller may immediately begin to transfer data into the buffers via the Buffer pointer. The buffer will already be marked dirty. The caller MUST subsequently call CcUnpinData. Naturally if CcPinRead or CcPreparePinWrite were called multiple times for the same data, CcUnpinData must be called the same number of times. The returned Buffer pointer is valid until the data is unpinned, at which point it is invalid to use the pointer further. Arguments: FileObject - Pointer to the file object for a file which was opened with NO_INTERMEDIATE_BUFFERING clear, i.e., for which CcInitializeCacheMap was called by the file system. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. Zero - If supplied as TRUE, the buffer will be zeroed on return. Flags - (PIN_WAIT, PIN_EXCLUSIVE, PIN_NO_READ, etc. as defined in cache.h) If the caller specifies PIN_NO_READ and PIN_EXCLUSIVE, then he must guarantee that no one else will be attempting to map the view, if he wants to guarantee that the Bcb is not mapped (view may be purged). If the caller specifies PIN_NO_READ without PIN_EXCLUSIVE, the data may or may not be mapped in the return Bcb. Bcb - This returns a pointer to a Bcb parameter which must be supplied as input to CcPinWriteComplete. Buffer - Returns pointer to desired data, valid until the buffer is unpinned or freed. Return Value: FALSE - if Wait was not set and the data was not delivered TRUE - if the pages are being delivered --*/ { PSHARED_CACHE_MAP SharedCacheMap; PVOID LocalBuffer; LARGE_INTEGER BeyondLastByte; LARGE_INTEGER LocalFileOffset = *FileOffset; POBCB MyBcb = NULL; PBCB *CurrentBcbPtr = (PBCB *)&MyBcb; ULONG OriginalLength = Length; BOOLEAN Result = FALSE; DebugTrace(+1, me, "CcPreparePinWrite\n", 0 ); // // Get pointer to SharedCacheMap. // SharedCacheMap = *(PSHARED_CACHE_MAP *)((PCHAR)FileObject->SectionObjectPointer + sizeof(PVOID)); try { // // Form loop to handle occassional overlapped Bcb case. // do { // // If we have already been through the loop, then adjust // our file offset and length from the last time. // if (MyBcb != NULL) { // // If this is the second time through the loop, then it is time // to handle the overlap case and allocate an OBCB. // if (CurrentBcbPtr == (PBCB *)&MyBcb) { MyBcb = CcAllocateObcb( FileOffset, Length, (PBCB)MyBcb ); // // Set CurrentBcbPtr to point at the first entry in // the vector (which is already filled in), before // advancing it below. // CurrentBcbPtr = &MyBcb->Bcbs[0]; // // Also on second time through, return starting Buffer // *Buffer = LocalBuffer; } Length -= (ULONG)(BeyondLastByte.QuadPart - LocalFileOffset.QuadPart); LocalFileOffset.QuadPart = BeyondLastByte.QuadPart; CurrentBcbPtr += 1; } // // Call local routine to Map or Access the file data. If we cannot map // the data because of a Wait condition, return FALSE. // if (!CcPinFileData( FileObject, &LocalFileOffset, Length, FALSE, TRUE, Flags, CurrentBcbPtr, &LocalBuffer, &BeyondLastByte )) { try_return( Result = FALSE ); } // // Continue looping if we did not get everything. // } while((BeyondLastByte.QuadPart - LocalFileOffset.QuadPart) < Length); *Bcb = MyBcb; // // Debug routines used to insert and remove Bcbs from the global list // #if LIST_DBG { KIRQL OldIrql; PBCB BcbTemp = (PBCB)*Bcb; ExAcquireSpinLock( &CcBcbSpinLock, &OldIrql ); if (BcbTemp->CcBcbLinks.Flink == NULL) { InsertTailList( &CcBcbList, &BcbTemp->CcBcbLinks ); CcBcbCount += 1; ExReleaseSpinLock( &CcBcbSpinLock, OldIrql ); SetCallersAddress( BcbTemp ); } else { ExReleaseSpinLock( &CcBcbSpinLock, OldIrql ); } } #endif // // In the normal (nonoverlapping) case we return the // correct buffer address here. // if (CurrentBcbPtr == (PBCB *)&MyBcb) { *Buffer = LocalBuffer; } if (Zero) { RtlZeroMemory( *Buffer, OriginalLength ); } CcSetDirtyPinnedData( MyBcb, NULL ); Result = TRUE; try_exit: NOTHING; } finally { CcMissCounter = &CcThrowAway; if (!Result) { // // We may have gotten partway through // if (MyBcb != NULL) { CcUnpinData( MyBcb ); } } DebugTrace(-1, me, "CcPreparePinWrite -> %02lx\n", Result ); } return Result; }

VOID CcSetBcbOwnerPointer (  IN PVOID  Bcb, IN PVOID  OwnerPointer )

Definition at line 1078 of file pinsup.c. References ASSERT, CACHE_NTC_OBCB, ExSetResourceOwnerPointer(), NULL, and Resource. Referenced by LfsGetLbcb(). : This routine may be called to set the resource owner for the Bcb resource, for cases where another thread will do the unpin *and* the current thread may exit. Arguments: Bcb - Bcb parameter returned from the last call to CcPinRead. OwnerPointer - A valid resource owner pointer, which means a pointer to an allocated system address, with the low-order two bits set. The address may not be deallocated until after the unpin call. Return Value: None. --*/ { ASSERT(((ULONG_PTR)Bcb & 1) == 0); // // Handle the overlapped Bcb case. // if (((POBCB)Bcb)->NodeTypeCode == CACHE_NTC_OBCB) { PBCB *BcbPtrPtr = &((POBCB)Bcb)->Bcbs[0]; // // Loop to set owner for all Bcbs. // while (*BcbPtrPtr != NULL) { ExSetResourceOwnerPointer( &(*BcbPtrPtr)->Resource, OwnerPointer ); BcbPtrPtr++; } // // Otherwise, it is a normal Bcb // } else { // // Handle normal case. // ExSetResourceOwnerPointer( &((PBCB)Bcb)->Resource, OwnerPointer ); } }

VOID CcUnpinData (  IN PVOID  Bcb  )

Definition at line 1000 of file pinsup.c. References CACHE_NTC_OBCB, CcUnpinFileData(), DebugTrace, ExFreePool(), FALSE, me, NULL, TRUE, and UNPIN. Referenced by CcPinMappedData(), CcPinRead(), CcPreparePinWrite(), LfsCopyReadLogRecord(), LfsDeallocateLcb(), LfsFindLastLsn(), LfsFindNextLsn(), LfsFlushLfcb(), LfsFlushLogPage(), LfsGetLbcb(), LfsInitializeLogFilePriv(), LfsPinOrMapData(), LfsReadNextLogRecord(), LfsReadRestart(), LfsReadRestartArea(), LfsRestartLogFile(), and LfsSearchForwardByClient(). : This routine must be called at IPL0, some time after calling CcPinRead or CcPreparePinWrite. It performs any cleanup that is necessary. Arguments: Bcb - Bcb parameter returned from the last call to CcPinRead. Return Value: None. --*/ { DebugTrace(+1, me, "CcUnpinData:\n", 0 ); DebugTrace( 0, me, " >Bcb = %08lx\n", Bcb ); // // Test for ReadOnly and unpin accordingly. // if (((ULONG_PTR)Bcb & 1) != 0) { // // Remove the Read Only flag // (PCHAR)Bcb -= 1; CcUnpinFileData( (PBCB)Bcb, TRUE, UNPIN ); } else { // // Handle the overlapped Bcb case. // if (((POBCB)Bcb)->NodeTypeCode == CACHE_NTC_OBCB) { PBCB *BcbPtrPtr = &((POBCB)Bcb)->Bcbs[0]; // // Loop to free all Bcbs with recursive calls // (rather than dealing with RO for this uncommon case). // while (*BcbPtrPtr != NULL) { CcUnpinData(*(BcbPtrPtr++)); } // // Then free the pool for the Obcb // ExFreePool( Bcb ); // // Otherwise, it is a normal Bcb // } else { CcUnpinFileData( (PBCB)Bcb, FALSE, UNPIN ); } } DebugTrace(-1, me, "CcUnPinData -> VOID\n", 0 ); }

VOID CcUnpinDataForThread (  IN PVOID  Bcb, IN ERESOURCE_THREAD  ResourceThreadId )

Definition at line 1142 of file pinsup.c. References CACHE_NTC_OBCB, CcUnpinFileData(), DebugTrace, ExFreePool(), ExReleaseResourceForThread, me, NULL, Resource, TRUE, and UNPIN. Referenced by LfsCloseLogFile(), and LfsFlushLfcb(). : This routine must be called at IPL0, some time after calling CcPinRead or CcPreparePinWrite. It performs any cleanup that is necessary, releasing the Bcb resource for the given thread. Arguments: Bcb - Bcb parameter returned from the last call to CcPinRead. Return Value: None. --*/ { DebugTrace(+1, me, "CcUnpinDataForThread:\n", 0 ); DebugTrace( 0, me, " >Bcb = %08lx\n", Bcb ); DebugTrace( 0, me, " >ResoureceThreadId = %08lx\n", ResoureceThreadId ); // // Test for ReadOnly and unpin accordingly. // if (((ULONG_PTR)Bcb & 1) != 0) { // // Remove the Read Only flag // (PCHAR)Bcb -= 1; CcUnpinFileData( (PBCB)Bcb, TRUE, UNPIN ); } else { // // Handle the overlapped Bcb case. // if (((POBCB)Bcb)->NodeTypeCode == CACHE_NTC_OBCB) { PBCB *BcbPtrPtr = &((POBCB)Bcb)->Bcbs[0]; // // Loop to free all Bcbs with recursive calls // (rather than dealing with RO for this uncommon case). // while (*BcbPtrPtr != NULL) { CcUnpinDataForThread( *(BcbPtrPtr++), ResourceThreadId ); } // // Then free the pool for the Obcb // ExFreePool( Bcb ); // // Otherwise, it is a normal Bcb // } else { // // If not readonly, we can release the resource for the thread first, // and then call CcUnpinFileData. Release resource first in case // Bcb gets deallocated. // ExReleaseResourceForThread( &((PBCB)Bcb)->Resource, ResourceThreadId ); CcUnpinFileData( (PBCB)Bcb, TRUE, UNPIN ); } } DebugTrace(-1, me, "CcUnpinDataForThread -> VOID\n", 0 ); }

---