cache.h File Reference

Go to the source code of this file.

Classes
struct	_PUBLIC_BCB
struct	_CC_FILE_SIZES
struct	_CACHE_MANAGER_CALLBACKS
struct	_CACHE_UNINITIALIZE_EVENT
Defines
#define	VACB_MAPPING_GRANULARITY   (0x40000)
#define	VACB_OFFSET_SHIFT   (18)
#define	CcIsFileCached(FO)
#define	CcGetFileSizePointer(FO)
#define	CcCopyWriteWontFlush(FO, FOFF, LEN)   ((LEN) <= 0X10000)
#define	CcReadAhead(FO, FOFF, LEN)
#define	PIN_WAIT   (1)
#define	PIN_EXCLUSIVE   (2)
#define	PIN_NO_READ   (4)
#define	PIN_IF_BCB   (8)
Typedefs
typedef _PUBLIC_BCB	PUBLIC_BCB
typedef _PUBLIC_BCB *	PPUBLIC_BCB
typedef _CC_FILE_SIZES	CC_FILE_SIZES
typedef _CC_FILE_SIZES *	PCC_FILE_SIZES
typedef BOOLEAN(*	PACQUIRE_FOR_LAZY_WRITE )(IN PVOID Context, IN BOOLEAN Wait)
typedef VOID(*	PRELEASE_FROM_LAZY_WRITE )(IN PVOID Context)
typedef BOOLEAN(*	PACQUIRE_FOR_READ_AHEAD )(IN PVOID Context, IN BOOLEAN Wait)
typedef VOID(*	PRELEASE_FROM_READ_AHEAD )(IN PVOID Context)
typedef _CACHE_MANAGER_CALLBACKS	CACHE_MANAGER_CALLBACKS
typedef _CACHE_MANAGER_CALLBACKS *	PCACHE_MANAGER_CALLBACKS
typedef _CACHE_UNINITIALIZE_EVENT	CACHE_UNINITIALIZE_EVENT
typedef _CACHE_UNINITIALIZE_EVENT *	PCACHE_UNINITIALIZE_EVENT
typedef VOID(*	PDIRTY_PAGE_ROUTINE )(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN PLARGE_INTEGER OldestLsn, IN PLARGE_INTEGER NewestLsn, IN PVOID Context1, IN PVOID Context2)
typedef VOID(*	PFLUSH_TO_LSN )(IN PVOID LogHandle, IN LARGE_INTEGER Lsn)
typedef VOID(*	PCC_POST_DEFERRED_WRITE )(IN PVOID Context1, IN PVOID Context2)
Functions
NTKERNELAPI BOOLEAN	CcInitializeCacheManager ()
NTKERNELAPI VOID	CcInitializeCacheMap (IN PFILE_OBJECT FileObject, IN PCC_FILE_SIZES FileSizes, IN BOOLEAN PinAccess, IN PCACHE_MANAGER_CALLBACKS Callbacks, IN PVOID LazyWriteContext)
NTKERNELAPI BOOLEAN	CcUninitializeCacheMap (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER TruncateSize OPTIONAL, IN PCACHE_UNINITIALIZE_EVENT UninitializeCompleteEvent OPTIONAL)
NTKERNELAPI VOID	CcSetFileSizes (IN PFILE_OBJECT FileObject, IN PCC_FILE_SIZES FileSizes)
NTKERNELAPI BOOLEAN	CcPurgeCacheSection (IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN PLARGE_INTEGER FileOffset OPTIONAL, IN ULONG Length, IN BOOLEAN UninitializeCacheMaps)
NTKERNELAPI VOID	CcSetDirtyPageThreshold (IN PFILE_OBJECT FileObject, IN ULONG DirtyPageThreshold)
NTKERNELAPI VOID	CcFlushCache (IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN PLARGE_INTEGER FileOffset OPTIONAL, IN ULONG Length, OUT PIO_STATUS_BLOCK IoStatus OPTIONAL)
NTKERNELAPI LARGE_INTEGER	CcGetFlushedValidData (IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN BOOLEAN BcbListHeld)
NTKERNELAPI VOID	CcZeroEndOfLastPage (IN PFILE_OBJECT FileObject)
NTKERNELAPI BOOLEAN	CcZeroData (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER StartOffset, IN PLARGE_INTEGER EndOffset, IN BOOLEAN Wait)
NTKERNELAPI PVOID	CcRemapBcb (IN PVOID Bcb)
NTKERNELAPI VOID	CcRepinBcb (IN PVOID Bcb)
NTKERNELAPI VOID	CcUnpinRepinnedBcb (IN PVOID Bcb, IN BOOLEAN WriteThrough, OUT PIO_STATUS_BLOCK IoStatus)
NTKERNELAPI PFILE_OBJECT	CcGetFileObjectFromSectionPtrs (IN PSECTION_OBJECT_POINTERS SectionObjectPointer)
NTKERNELAPI PFILE_OBJECT	CcGetFileObjectFromBcb (IN PVOID Bcb)
NTKERNELAPI BOOLEAN	CcCanIWrite (IN PFILE_OBJECT FileObject, IN ULONG BytesToWrite, IN BOOLEAN Wait, IN BOOLEAN Retrying)
NTKERNELAPI VOID	CcDeferWrite (IN PFILE_OBJECT FileObject, IN PCC_POST_DEFERRED_WRITE PostRoutine, IN PVOID Context1, IN PVOID Context2, IN ULONG BytesToWrite, IN BOOLEAN Retrying)
NTKERNELAPI BOOLEAN	CcCopyRead (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus)
NTKERNELAPI VOID	CcFastCopyRead (IN PFILE_OBJECT FileObject, IN ULONG FileOffset, IN ULONG Length, IN ULONG PageCount, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus)
NTKERNELAPI BOOLEAN	CcCopyWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN PVOID Buffer)
NTKERNELAPI VOID	CcFastCopyWrite (IN PFILE_OBJECT FileObject, IN ULONG FileOffset, IN ULONG Length, IN PVOID Buffer)
NTKERNELAPI VOID	CcMdlRead (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
NTKERNELAPI VOID	CcMdlReadComplete (IN PFILE_OBJECT FileObject, IN PMDL MdlChain)
NTKERNELAPI VOID	CcMdlReadComplete2 (IN PFILE_OBJECT FileObject, IN PMDL MdlChain)
NTKERNELAPI VOID	CcPrepareMdlWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
NTKERNELAPI VOID	CcMdlWriteComplete (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PMDL MdlChain)
NTKERNELAPI VOID	CcMdlWriteComplete2 (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PMDL MdlChain)
NTKERNELAPI VOID	CcScheduleReadAhead (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length)
NTSTATUS	CcWaitForCurrentLazyWriterActivity ()
NTKERNELAPI VOID	CcSetReadAheadGranularity (IN PFILE_OBJECT FileObject, IN ULONG Granularity)
NTKERNELAPI BOOLEAN	CcPinRead (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG Flags, OUT PVOID *Bcb, OUT PVOID *Buffer)
NTKERNELAPI BOOLEAN	CcMapData (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, OUT PVOID *Bcb, OUT PVOID *Buffer)
NTKERNELAPI BOOLEAN	CcPinMappedData (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG Flags, IN OUT PVOID *Bcb)
NTKERNELAPI 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)
NTKERNELAPI VOID	CcSetDirtyPinnedData (IN PVOID BcbVoid, IN PLARGE_INTEGER Lsn OPTIONAL)
NTKERNELAPI VOID	CcUnpinData (IN PVOID Bcb)
NTKERNELAPI VOID	CcSetBcbOwnerPointer (IN PVOID Bcb, IN PVOID OwnerPointer)
NTKERNELAPI VOID	CcUnpinDataForThread (IN PVOID Bcb, IN ERESOURCE_THREAD ResourceThreadId)
NTKERNELAPI VOID	CcSetAdditionalCacheAttributes (IN PFILE_OBJECT FileObject, IN BOOLEAN DisableReadAhead, IN BOOLEAN DisableWriteBehind)
NTKERNELAPI VOID	CcSetLogHandleForFile (IN PFILE_OBJECT FileObject, IN PVOID LogHandle, IN PFLUSH_TO_LSN FlushToLsnRoutine)
NTKERNELAPI LARGE_INTEGER	CcGetDirtyPages (IN PVOID LogHandle, IN PDIRTY_PAGE_ROUTINE DirtyPageRoutine, IN PVOID Context1, IN PVOID Context2)
NTKERNELAPI BOOLEAN	CcIsThereDirtyData (IN PVPB Vpb)
NTKERNELAPI LARGE_INTEGER	CcGetLsnForFileObject (IN PFILE_OBJECT FileObject, OUT PLARGE_INTEGER OldestLsn OPTIONAL)
Variables
ULONG	CcThrowAway
ULONG	CcFastReadNoWait
ULONG	CcFastReadWait
ULONG	CcFastReadResourceMiss
ULONG	CcFastReadNotPossible
ULONG	CcFastMdlReadNoWait
ULONG	CcFastMdlReadWait
ULONG	CcFastMdlReadResourceMiss
ULONG	CcFastMdlReadNotPossible
ULONG	CcMapDataNoWait
ULONG	CcMapDataWait
ULONG	CcMapDataNoWaitMiss
ULONG	CcMapDataWaitMiss
ULONG	CcPinMappedDataCount
ULONG	CcPinReadNoWait
ULONG	CcPinReadWait
ULONG	CcPinReadNoWaitMiss
ULONG	CcPinReadWaitMiss
ULONG	CcCopyReadNoWait
ULONG	CcCopyReadWait
ULONG	CcCopyReadNoWaitMiss
ULONG	CcCopyReadWaitMiss
ULONG	CcMdlReadNoWait
ULONG	CcMdlReadWait
ULONG	CcMdlReadNoWaitMiss
ULONG	CcMdlReadWaitMiss
ULONG	CcReadAheadIos
ULONG	CcLazyWriteIos
ULONG	CcLazyWritePages
ULONG	CcDataFlushes
ULONG	CcDataPages
PULONG	CcMissCounter

---

Define Documentation

#define CcCopyWriteWontFlush (  FO, FOFF, LEN   )     ((LEN) <= 0X10000)

Definition at line 375 of file cache.h. Referenced by FsRtlCopyWrite().

#define CcGetFileSizePointer (  FO   )

Value: ( \ ((PLARGE_INTEGER)((FO)->SectionObjectPointer->SharedCacheMap) + 1) \ ) Definition at line 277 of file cache.h. Referenced by FsRtlCopyWrite(), and FsRtlPrepareMdlWriteDev().

#define CcIsFileCached (  FO   )

Value: ( \ ((FO)->SectionObjectPointer != NULL) && \ (((PSECTION_OBJECT_POINTERS)(FO)->SectionObjectPointer)->SharedCacheMap != NULL) \ ) Definition at line 173 of file cache.h. Referenced by IoSynchronousPageWrite().

#define CcReadAhead (  FO, FOFF, LEN   )

Value: { \ if ((LEN) >= 256) { \ CcScheduleReadAhead((FO),(FOFF),(LEN)); \ } \ } Definition at line 531 of file cache.h.

#define PIN_EXCLUSIVE   (2)

Definition at line 590 of file cache.h. Referenced by CcPinFileData().

#define PIN_IF_BCB   (8)

Definition at line 609 of file cache.h. Referenced by CcPinFileData().

#define PIN_NO_READ   (4)

Definition at line 600 of file cache.h. Referenced by CcPinFileData().

#define PIN_WAIT   (1)

Definition at line 582 of file cache.h. Referenced by CcPinFileData(), CcPinMappedData(), and CcPinRead().

#define VACB_MAPPING_GRANULARITY   (0x40000)

Definition at line 30 of file cache.h. Referenced by CcCopyRead(), CcCopyWrite(), CcCreateVacbArray(), CcFastCopyRead(), CcFastCopyWrite(), CcFreeActiveVacb(), CcGetVacbMiss(), CcGetVirtualAddress(), CcGetVirtualAddressIfMapped(), CcInitializeCacheMap(), CcPinFileData(), CcUnmapVacbArray(), UdfLookupDirEntryPostProcessing(), and UdfLookupInitialDirEntry().

#define VACB_OFFSET_SHIFT   (18)

Definition at line 31 of file cache.h. Referenced by CcAdjustVacbLevelLockCount(), CcCopyRead(), CcCreateVacbArray(), CcExtendVacbArray(), CcFastCopyRead(), CcGetBcbListHeadLargeOffset(), CcGetVacbLargeOffset(), CcInitializeVacbs(), CcSetVacbLargeOffset(), and SetVacb().

---

Typedef Documentation

typedef struct _CACHE_MANAGER_CALLBACKS CACHE_MANAGER_CALLBACKS

typedef struct _CACHE_UNINITIALIZE_EVENT CACHE_UNINITIALIZE_EVENT

typedef struct _CC_FILE_SIZES CC_FILE_SIZES

typedef BOOLEAN(* PACQUIRE_FOR_LAZY_WRITE)(IN PVOID Context, IN BOOLEAN Wait)

Definition at line 90 of file cache.h.

typedef BOOLEAN(* PACQUIRE_FOR_READ_AHEAD)(IN PVOID Context, IN BOOLEAN Wait)

Definition at line 109 of file cache.h.

typedef struct _CACHE_MANAGER_CALLBACKS * PCACHE_MANAGER_CALLBACKS

typedef struct _CACHE_UNINITIALIZE_EVENT * PCACHE_UNINITIALIZE_EVENT

typedef struct _CC_FILE_SIZES * PCC_FILE_SIZES

Referenced by UdfCommonRead(), and UdfLookupMetaVsnOfExtent().

typedef VOID(* PCC_POST_DEFERRED_WRITE)(IN PVOID Context1, IN PVOID Context2)

Definition at line 387 of file cache.h.

typedef VOID(* PDIRTY_PAGE_ROUTINE)(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN PLARGE_INTEGER OldestLsn, IN PLARGE_INTEGER NewestLsn, IN PVOID Context1, IN PVOID Context2)

Definition at line 148 of file cache.h.

typedef VOID(* PFLUSH_TO_LSN)(IN PVOID LogHandle, IN LARGE_INTEGER Lsn)

Definition at line 163 of file cache.h.

typedef struct _PUBLIC_BCB * PPUBLIC_BCB

typedef VOID(* PRELEASE_FROM_LAZY_WRITE)(IN PVOID Context)

Definition at line 100 of file cache.h.

typedef VOID(* PRELEASE_FROM_READ_AHEAD)(IN PVOID Context)

Definition at line 119 of file cache.h.

typedef struct _PUBLIC_BCB PUBLIC_BCB

---

Function Documentation

NTKERNELAPI BOOLEAN CcCanIWrite (  IN PFILE_OBJECT  FileObject, IN ULONG  BytesToWrite, IN BOOLEAN  Wait, IN BOOLEAN  Retrying )

Referenced by CcLazyWriteScan(), CcPostDeferredWrites(), FsRtlCopyWrite(), and FsRtlPrepareMdlWriteDev().

NTKERNELAPI BOOLEAN CcCopyRead (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, IN BOOLEAN  Wait, OUT PVOID  Buffer, OUT PIO_STATUS_BLOCK  IoStatus )

Definition at line 31 of file copysup.c. References ASSERT, _VACB::BaseAddress, _PRIVATE_CACHE_MAP::BeyondLastByte1, _PRIVATE_CACHE_MAP::BeyondLastByte2, Buffer, CcCopyReadExceptionFilter(), CcCopyReadNoWait, CcCopyReadNoWaitMiss, CcCopyReadWait, CcCopyReadWaitMiss, CcFreeActiveVacb(), CcFreeVirtualAddress(), CcGetVirtualAddress(), CcMissCounter, CcPinFileData(), CcScheduleReadAhead(), CcThrowAway, CcUnpinFileData(), COMPUTE_PAGES_SPANNED, DebugTrace, ExRaiseStatus(), FALSE, _PRIVATE_CACHE_MAP::FileOffset1, _PRIVATE_CACHE_MAP::FileOffset2, _SHARED_CACHE_MAP::FileSize, FlagOn, FO_RANDOM_ACCESS, FsRtlNormalizeNtstatus(), GetActiveVacb, HOT_STATISTIC, me, MmCheckCachedPageState(), MmResetPageFaultReadAhead, MmSavePageFaultReadAhead, MmSetPageFaultReadAhead, _SHARED_CACHE_MAP::NeedToZero, NTSTATUS(), NULL, PAGE_SHIFT, PsGetCurrentThread, _PRIVATE_CACHE_MAP::ReadAheadEnabled, _PRIVATE_CACHE_MAP::ReadAheadLength, ROUND_TO_PAGES, SetActiveVacb, Status, TRUE, UNPIN, VACB_MAPPING_GRANULARITY, and VACB_OFFSET_SHIFT. Referenced by FsRtlCopyRead(), and UdfCommonRead(). : This routine attempts to copy the specified file data from the cache into the output buffer, and deliver the correct I/O status. It is *not* safe to call this routine from Dpc level. If the caller does not want to block (such as for disk I/O), then Wait should be supplied as FALSE. If Wait was supplied as FALSE and it is currently impossible to supply all of 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 copies the data and returns TRUE. If the caller supplies Wait as TRUE, then this routine is guaranteed to copy the data and return TRUE. If the data is immediately accessible in the cache, then no blocking will occur. Otherwise, the the data transfer from the file into the cache will be initiated, and the caller will be blocked until the data can be returned. File system Fsd's should typically supply Wait = TRUE if they are processing a synchronous I/O requests, or Wait = FALSE if they are processing an asynchronous request. File system or Server Fsp threads should supply Wait = TRUE. 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) Buffer - Pointer to output buffer to which data should be copied. IoStatus - Pointer to standard I/O status block to receive the status for the transfer. (STATUS_SUCCESS guaranteed for cache hits, otherwise the actual I/O status is returned.) Note that even if FALSE is returned, the IoStatus.Information field will return the count of any bytes successfully transferred before a blocking condition occured. The caller may either choose to ignore this information, or resume the copy later accounting for bytes transferred. 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; PPRIVATE_CACHE_MAP PrivateCacheMap; PVOID CacheBuffer; LARGE_INTEGER FOffset; PVACB Vacb; PBCB Bcb; PVACB ActiveVacb; ULONG ActivePage; ULONG PageIsDirty; ULONG SavedState; ULONG PagesToGo; ULONG MoveLength; ULONG LengthToGo; KIRQL OldIrql; NTSTATUS Status; ULONG OriginalLength = Length; ULONG PageCount = COMPUTE_PAGES_SPANNED((ULongToPtr(FileOffset->LowPart)), Length); PETHREAD Thread = PsGetCurrentThread(); ULONG GotAMiss = 0; DebugTrace(+1, me, "CcCopyRead\n", 0 ); MmSavePageFaultReadAhead( Thread, &SavedState ); // // Get pointer to shared and private cache maps // SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; PrivateCacheMap = FileObject->PrivateCacheMap; // // Check for read past file size, the caller must filter this case out. // ASSERT( ( FileOffset->QuadPart + (LONGLONG)Length) <= SharedCacheMap->FileSize.QuadPart ); // // If read ahead is enabled, then do the read ahead here so it // overlaps with the copy (otherwise we will do it below). // Note that we are assuming that we will not get ahead of our // current transfer - if read ahead is working it should either // already be in memory or else underway. // if (PrivateCacheMap->ReadAheadEnabled && (PrivateCacheMap->ReadAheadLength[1] == 0)) { CcScheduleReadAhead( FileObject, FileOffset, Length ); } FOffset = *FileOffset; // // Increment performance counters // if (Wait) { HOT_STATISTIC(CcCopyReadWait) += 1; // // This is not an exact solution, but when IoPageRead gets a miss, // it cannot tell whether it was CcCopyRead or CcMdlRead, but since // the miss should occur very soon, by loading the pointer here // probably the right counter will get incremented, and in any case, // we hope the errrors average out! // CcMissCounter = &CcCopyReadWaitMiss; } else { HOT_STATISTIC(CcCopyReadNoWait) += 1; } // // See if we have an active Vacb, that we can just copy to. // GetActiveVacb( SharedCacheMap, OldIrql, ActiveVacb, ActivePage, PageIsDirty ); if (ActiveVacb != NULL) { if ((ULONG)(FOffset.QuadPart >> VACB_OFFSET_SHIFT) == (ActivePage >> (VACB_OFFSET_SHIFT - PAGE_SHIFT))) { ULONG LengthToCopy = VACB_MAPPING_GRANULARITY - (FOffset.LowPart & (VACB_MAPPING_GRANULARITY - 1)); if (SharedCacheMap->NeedToZero != NULL) { CcFreeActiveVacb( SharedCacheMap, NULL, 0, FALSE ); } // // Get the starting point in the view. // CacheBuffer = (PVOID)((PCHAR)ActiveVacb->BaseAddress + (FOffset.LowPart & (VACB_MAPPING_GRANULARITY - 1))); // // Reduce LengthToCopy if it is greater than our caller's length. // if (LengthToCopy > Length) { LengthToCopy = Length; } // // Like the logic for the normal case below, we want to spin around // making sure Mm only reads the pages we will need. // PagesToGo = COMPUTE_PAGES_SPANNED( CacheBuffer, LengthToCopy ) - 1; // // Copy the data to the user buffer. // try { if (PagesToGo != 0) { LengthToGo = LengthToCopy; while (LengthToGo != 0) { MoveLength = (ULONG)((PCHAR)(ROUND_TO_PAGES(((PCHAR)CacheBuffer + 1))) - (PCHAR)CacheBuffer); if (MoveLength > LengthToGo) { MoveLength = LengthToGo; } // // Here's hoping that it is cheaper to call Mm to see if // the page is valid. If not let Mm know how many pages // we are after before doing the move. // MmSetPageFaultReadAhead( Thread, PagesToGo ); GotAMiss |= !MmCheckCachedPageState( CacheBuffer, FALSE ); RtlCopyBytes( Buffer, CacheBuffer, MoveLength ); PagesToGo -= 1; LengthToGo -= MoveLength; Buffer = (PCHAR)Buffer + MoveLength; CacheBuffer = (PCHAR)CacheBuffer + MoveLength; } // // Handle the read here that stays on a single page. // } else { // // Here's hoping that it is cheaper to call Mm to see if // the page is valid. If not let Mm know how many pages // we are after before doing the move. // MmSetPageFaultReadAhead( Thread, 0 ); GotAMiss |= !MmCheckCachedPageState( CacheBuffer, FALSE ); RtlCopyBytes( Buffer, CacheBuffer, LengthToCopy ); Buffer = (PCHAR)Buffer + LengthToCopy; } } except( CcCopyReadExceptionFilter( GetExceptionInformation(), &Status ) ) { MmResetPageFaultReadAhead( Thread, SavedState ); SetActiveVacb( SharedCacheMap, OldIrql, ActiveVacb, ActivePage, PageIsDirty ); // // If we got an access violation, then the user buffer went // away. Otherwise we must have gotten an I/O error trying // to bring the data in. // if (Status == STATUS_ACCESS_VIOLATION) { ExRaiseStatus( STATUS_INVALID_USER_BUFFER ); } else { ExRaiseStatus( FsRtlNormalizeNtstatus( Status, STATUS_UNEXPECTED_IO_ERROR )); } } // // Now adjust FOffset and Length by what we copied. // FOffset.QuadPart = FOffset.QuadPart + (LONGLONG)LengthToCopy; Length -= LengthToCopy; } // // If that was all the data, then remember the Vacb // if (Length == 0) { SetActiveVacb( SharedCacheMap, OldIrql, ActiveVacb, ActivePage, PageIsDirty ); // // Otherwise we must free it because we will map other vacbs below. // } else { CcFreeActiveVacb( SharedCacheMap, ActiveVacb, ActivePage, PageIsDirty ); } } // // Not all of the transfer will come back at once, so we have to loop // until the entire transfer is complete. // while (Length != 0) { ULONG ReceivedLength; LARGE_INTEGER BeyondLastByte; // // Call local routine to Map or Access the file data, then move the data, // then call another local routine to free the data. If we cannot map // the data because of a Wait condition, return FALSE. // // Note that this call may result in an exception, however, if it // does no Bcb is returned and this routine has absolutely no // cleanup to perform. Therefore, we do not have a try-finally // and we allow the possibility that we will simply be unwound // without notice. // if (Wait) { CacheBuffer = CcGetVirtualAddress( SharedCacheMap, FOffset, &Vacb, &ReceivedLength ); BeyondLastByte.QuadPart = FOffset.QuadPart + (LONGLONG)ReceivedLength; } else if (!CcPinFileData( FileObject, &FOffset, Length, TRUE, FALSE, FALSE, &Bcb, &CacheBuffer, &BeyondLastByte )) { DebugTrace(-1, me, "CcCopyRead -> FALSE\n", 0 ); HOT_STATISTIC(CcCopyReadNoWaitMiss) += 1; // // Enable ReadAhead if we missed. // PrivateCacheMap->ReadAheadEnabled = TRUE; return FALSE; } else { // // Calculate how much data is described by Bcb starting at our desired // file offset. // ReceivedLength = (ULONG)(BeyondLastByte.QuadPart - FOffset.QuadPart); } // // If we got more than we need, make sure to only transfer // the right amount. // if (ReceivedLength > Length) { ReceivedLength = Length; } // // It is possible for the user buffer to become no longer accessible // since it was last checked by the I/O system. If we fail to access // the buffer we must raise a status that the caller's exception // filter considers as "expected". Also we unmap the Bcb here, since // we otherwise would have no other reason to put a try-finally around // this loop. // try { PagesToGo = COMPUTE_PAGES_SPANNED( CacheBuffer, ReceivedLength ) - 1; // // We know exactly how much we want to read here, and we do not // want to read any more in case the caller is doing random access. // Our read ahead logic takes care of detecting sequential reads, // and tends to do large asynchronous read aheads. So far we have // only mapped the data and we have not forced any in. What we // do now is get into a loop where we copy a page at a time and // just prior to each move, we tell MM how many additional pages // we would like to have read in, in the event that we take a // fault. With this strategy, for cache hits we never make a single // expensive call to MM to guarantee that the data is in, yet if we // do take a fault, we are guaranteed to only take one fault because // we will read all of the data in for the rest of the transfer. // // We test first for the multiple page case, to keep the small // reads faster. // if (PagesToGo != 0) { LengthToGo = ReceivedLength; while (LengthToGo != 0) { MoveLength = (ULONG)((PCHAR)(ROUND_TO_PAGES(((PCHAR)CacheBuffer + 1))) - (PCHAR)CacheBuffer); if (MoveLength > LengthToGo) { MoveLength = LengthToGo; } // // Here's hoping that it is cheaper to call Mm to see if // the page is valid. If not let Mm know how many pages // we are after before doing the move. // MmSetPageFaultReadAhead( Thread, PagesToGo ); GotAMiss |= !MmCheckCachedPageState( CacheBuffer, FALSE ); RtlCopyBytes( Buffer, CacheBuffer, MoveLength ); PagesToGo -= 1; LengthToGo -= MoveLength; Buffer = (PCHAR)Buffer + MoveLength; CacheBuffer = (PCHAR)CacheBuffer + MoveLength; } // // Handle the read here that stays on a single page. // } else { // // Here's hoping that it is cheaper to call Mm to see if // the page is valid. If not let Mm know how many pages // we are after before doing the move. // MmSetPageFaultReadAhead( Thread, 0 ); GotAMiss |= !MmCheckCachedPageState( CacheBuffer, FALSE ); RtlCopyBytes( Buffer, CacheBuffer, ReceivedLength ); Buffer = (PCHAR)Buffer + ReceivedLength; } } except( CcCopyReadExceptionFilter( GetExceptionInformation(), &Status ) ) { CcMissCounter = &CcThrowAway; // // If we get an exception, then we have to renable page fault // clustering and unmap on the way out. // MmResetPageFaultReadAhead( Thread, SavedState ); if (Wait) { CcFreeVirtualAddress( Vacb ); } else { CcUnpinFileData( Bcb, TRUE, UNPIN ); } // // If we got an access violation, then the user buffer went // away. Otherwise we must have gotten an I/O error trying // to bring the data in. // if (Status == STATUS_ACCESS_VIOLATION) { ExRaiseStatus( STATUS_INVALID_USER_BUFFER ); } else { ExRaiseStatus( FsRtlNormalizeNtstatus( Status, STATUS_UNEXPECTED_IO_ERROR )); } } // // Update number of bytes transferred. // Length -= ReceivedLength; // // Unmap the data now, and calculate length left to transfer. // if (Wait) { // // If there is more to go, just free this vacb. // if (Length != 0) { CcFreeVirtualAddress( Vacb ); // // Otherwise save it for the next time through. // } else { SetActiveVacb( SharedCacheMap, OldIrql, Vacb, (ULONG)(FOffset.QuadPart >> PAGE_SHIFT), 0 ); break; } } else { CcUnpinFileData( Bcb, TRUE, UNPIN ); } // // Assume we did not get all the data we wanted, and set FOffset // to the end of the returned data. // FOffset = BeyondLastByte; } MmResetPageFaultReadAhead( Thread, SavedState ); CcMissCounter = &CcThrowAway; // // Now enable read ahead if it looks like we got any misses, and do // the first one. // if (GotAMiss && !FlagOn( FileObject->Flags, FO_RANDOM_ACCESS ) && !PrivateCacheMap->ReadAheadEnabled) { PrivateCacheMap->ReadAheadEnabled = TRUE; CcScheduleReadAhead( FileObject, FileOffset, OriginalLength ); } // // Now that we have described our desired read ahead, let's // shift the read history down. // PrivateCacheMap->FileOffset1 = PrivateCacheMap->FileOffset2; PrivateCacheMap->BeyondLastByte1 = PrivateCacheMap->BeyondLastByte2; PrivateCacheMap->FileOffset2 = *FileOffset; PrivateCacheMap->BeyondLastByte2.QuadPart = FileOffset->QuadPart + (LONGLONG)OriginalLength; IoStatus->Status = STATUS_SUCCESS; IoStatus->Information = OriginalLength; DebugTrace(-1, me, "CcCopyRead -> TRUE\n", 0 ); return TRUE; }

NTKERNELAPI BOOLEAN CcCopyWrite (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, IN BOOLEAN  Wait, IN PVOID  Buffer )

Definition at line 1075 of file copysup.c. References ACTIVE_PAGE_IS_DIRTY, _SHARED_CACHE_MAP::ActiveVacbSpinLock, _VACB::BaseAddress, BooleanFlagOn, Buffer, CcCopyReadExceptionFilter(), CcFreeActiveVacb(), CcMapAndCopy(), CcPinFileData(), CcSetDirtyPinnedData(), CcUnpinFileData(), DebugTrace, ExRaiseStatus(), FALSE, FlagOn, FO_WRITE_THROUGH, FSRTL_FLAG_ADVANCED_HEADER, FsRtlNormalizeNtstatus(), GetActiveVacb, me, _SHARED_CACHE_MAP::NeedToZero, _SHARED_CACHE_MAP::NeedToZeroVacb, NTSTATUS(), NULL, PAGE_SHIFT, PAGE_SIZE, PFSRTL_ADVANCED_FCB_HEADER, SetActiveVacb, Status, TRUE, UNPIN, VACB_MAPPING_GRANULARITY, ZERO_FIRST_PAGE, ZERO_LAST_PAGE, and ZERO_MIDDLE_PAGES. Referenced by FsRtlCopyWrite(). : This routine attempts to copy the specified file data from the specified buffer into the Cache, and deliver the correct I/O status. It is *not* safe to call this routine from Dpc level. If the caller does not want to block (such as for disk I/O), then Wait should be supplied as FALSE. If Wait was supplied as FALSE and it is currently impossible to receive all of the requested data without blocking, then this routine will return FALSE. However, if the correct space is immediately accessible in the cache and no blocking is required, this routine copies the data and returns TRUE. If the caller supplies Wait as TRUE, then this routine is guaranteed to copy the data and return TRUE. If the correct space is immediately accessible in the cache, then no blocking will occur. Otherwise, the necessary work will be initiated to read and/or free cache data, and the caller will be blocked until the data can be received. File system Fsd's should typically supply Wait = TRUE if they are processing a synchronous I/O requests, or Wait = FALSE if they are processing an asynchronous request. File system or Server Fsp threads should supply Wait = TRUE. 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 to receive the data. Length - Length of data in bytes. Wait - FALSE if caller may not block, TRUE otherwise (see description above) Buffer - Pointer to input buffer from which data should be copied. Return Value: FALSE - if Wait was supplied as FALSE and the data was not copied. TRUE - if the data has been copied. Raises: STATUS_INSUFFICIENT_RESOURCES - If a pool allocation failure occurs. This can only occur if Wait was specified as TRUE. (If Wait is specified as FALSE, and an allocation failure occurs, this routine simply returns FALSE.) --*/ { PSHARED_CACHE_MAP SharedCacheMap; PFSRTL_ADVANCED_FCB_HEADER FcbHeader; PVACB ActiveVacb; ULONG ActivePage; PVOID ActiveAddress; ULONG PageIsDirty; KIRQL OldIrql; NTSTATUS Status; PVOID CacheBuffer; LARGE_INTEGER FOffset; PBCB Bcb; ULONG ZeroFlags; LARGE_INTEGER Temp; DebugTrace(+1, me, "CcCopyWrite\n", 0 ); // // If the caller specified Wait == FALSE, but the FileObject is WriteThrough, // then we need to just get out. // if ((FileObject->Flags & FO_WRITE_THROUGH) && !Wait) { DebugTrace(-1, me, "CcCopyWrite->FALSE (WriteThrough && !Wait)\n", 0 ); return FALSE; } // // Get pointer to shared cache map // SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; FOffset = *FileOffset; // // See if we have an active Vacb, that we can just copy to. // GetActiveVacb( SharedCacheMap, OldIrql, ActiveVacb, ActivePage, PageIsDirty ); if (ActiveVacb != NULL) { // // See if the request starts in the ActivePage. WriteThrough requests must // go the longer route through CcMapAndCopy, where WriteThrough flushes are // implemented. // if (((ULONG)(FOffset.QuadPart >> PAGE_SHIFT) == ActivePage) && (Length != 0) && !FlagOn( FileObject->Flags, FO_WRITE_THROUGH )) { ULONG LengthToCopy = PAGE_SIZE - (FOffset.LowPart & (PAGE_SIZE - 1)); // // Reduce LengthToCopy if it is greater than our caller's length. // if (LengthToCopy > Length) { LengthToCopy = Length; } // // Copy the data to the user buffer. // try { // // If we are copying to a page that is locked down, then // we have to do it under our spinlock, and update the // NeedToZero field. // OldIrql = 0xFF; CacheBuffer = (PVOID)((PCHAR)ActiveVacb->BaseAddress + (FOffset.LowPart & (VACB_MAPPING_GRANULARITY - 1))); if (SharedCacheMap->NeedToZero != NULL) { // // The FastLock may not write our "flag". // OldIrql = 0; ExAcquireFastLock( &SharedCacheMap->ActiveVacbSpinLock, &OldIrql ); // // Note that the NeedToZero could be cleared, since we // tested it without the spinlock. // ActiveAddress = SharedCacheMap->NeedToZero; if ((ActiveAddress != NULL) && (ActiveVacb == SharedCacheMap->NeedToZeroVacb) && (((PCHAR)CacheBuffer + LengthToCopy) > (PCHAR)ActiveAddress)) { // // If we are skipping some bytes in the page, then we need // to zero them. // if ((PCHAR)CacheBuffer > (PCHAR)ActiveAddress) { RtlZeroMemory( ActiveAddress, (PCHAR)CacheBuffer - (PCHAR)ActiveAddress ); } SharedCacheMap->NeedToZero = (PVOID)((PCHAR)CacheBuffer + LengthToCopy); } ExReleaseFastLock( &SharedCacheMap->ActiveVacbSpinLock, OldIrql ); } RtlCopyBytes( CacheBuffer, Buffer, LengthToCopy ); } except( CcCopyReadExceptionFilter( GetExceptionInformation(), &Status ) ) { // // If we failed to overwrite the uninitialized data, // zero it now (we cannot safely restore NeedToZero). // if (OldIrql != 0xFF) { RtlZeroBytes( CacheBuffer, LengthToCopy ); } SetActiveVacb( SharedCacheMap, OldIrql, ActiveVacb, ActivePage, ACTIVE_PAGE_IS_DIRTY ); // // If we got an access violation, then the user buffer went // away. Otherwise we must have gotten an I/O error trying // to bring the data in. // if (Status == STATUS_ACCESS_VIOLATION) { ExRaiseStatus( STATUS_INVALID_USER_BUFFER ); } else { ExRaiseStatus( FsRtlNormalizeNtstatus( Status, STATUS_UNEXPECTED_IO_ERROR )); } } // // Now adjust FOffset and Length by what we copied. // Buffer = (PVOID)((PCHAR)Buffer + LengthToCopy); FOffset.QuadPart = FOffset.QuadPart + (LONGLONG)LengthToCopy; Length -= LengthToCopy; // // If that was all the data, then get outski... // if (Length == 0) { SetActiveVacb( SharedCacheMap, OldIrql, ActiveVacb, ActivePage, ACTIVE_PAGE_IS_DIRTY ); return TRUE; } // // Remember that the page is dirty now. // PageIsDirty |= ACTIVE_PAGE_IS_DIRTY; } CcFreeActiveVacb( SharedCacheMap, ActiveVacb, ActivePage, PageIsDirty ); // // Else someone else could have the active page, and may want to zero // the range we plan to write! // } else if (SharedCacheMap->NeedToZero != NULL) { CcFreeActiveVacb( SharedCacheMap, NULL, 0, FALSE ); } // // At this point we can calculate the ZeroFlags. // // // We can always zero middle pages, if any. // ZeroFlags = ZERO_MIDDLE_PAGES; if (((FOffset.LowPart & (PAGE_SIZE - 1)) == 0) && (Length >= PAGE_SIZE)) { ZeroFlags |= ZERO_FIRST_PAGE; } if (((FOffset.LowPart + Length) & (PAGE_SIZE - 1)) == 0) { ZeroFlags |= ZERO_LAST_PAGE; } Temp = FOffset; Temp.LowPart &= ~(PAGE_SIZE -1); // // If there is an advanced header, then we can acquire the FastMutex to // make capturing ValidDataLength atomic. Currently our other file systems // are either RO or do not really support 64-bits. // FcbHeader = (PFSRTL_ADVANCED_FCB_HEADER)FileObject->FsContext; if (FlagOn(FcbHeader->Flags, FSRTL_FLAG_ADVANCED_HEADER)) { ExAcquireFastMutex( FcbHeader->FastMutex ); Temp.QuadPart = ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->ValidDataLength.QuadPart - Temp.QuadPart; ExReleaseFastMutex( FcbHeader->FastMutex ); } else { Temp.QuadPart = ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->ValidDataLength.QuadPart - Temp.QuadPart; } if (Temp.QuadPart <= 0) { ZeroFlags |= ZERO_FIRST_PAGE | ZERO_MIDDLE_PAGES | ZERO_LAST_PAGE; } else if ((Temp.HighPart == 0) && (Temp.LowPart <= PAGE_SIZE)) { ZeroFlags |= ZERO_MIDDLE_PAGES | ZERO_LAST_PAGE; } // // Call a routine to map and copy the data in Mm and get out. // if (Wait) { CcMapAndCopy( SharedCacheMap, Buffer, &FOffset, Length, ZeroFlags, BooleanFlagOn( FileObject->Flags, FO_WRITE_THROUGH )); return TRUE; } // // The rest of this routine is the Wait == FALSE case. // // Not all of the transfer will come back at once, so we have to loop // until the entire transfer is complete. // while (Length != 0) { ULONG ReceivedLength; LARGE_INTEGER BeyondLastByte; if (!CcPinFileData( FileObject, &FOffset, Length, FALSE, TRUE, FALSE, &Bcb, &CacheBuffer, &BeyondLastByte )) { DebugTrace(-1, me, "CcCopyWrite -> FALSE\n", 0 ); return FALSE; } else { // // Calculate how much data is described by Bcb starting at our desired // file offset. // ReceivedLength = (ULONG)(BeyondLastByte.QuadPart - FOffset.QuadPart); // // If we got more than we need, make sure to only transfer // the right amount. // if (ReceivedLength > Length) { ReceivedLength = Length; } } // // It is possible for the user buffer to become no longer accessible // since it was last checked by the I/O system. If we fail to access // the buffer we must raise a status that the caller's exception // filter considers as "expected". Also we unmap the Bcb here, since // we otherwise would have no other reason to put a try-finally around // this loop. // try { RtlCopyBytes( CacheBuffer, Buffer, ReceivedLength ); CcSetDirtyPinnedData( Bcb, NULL ); CcUnpinFileData( Bcb, FALSE, UNPIN ); } except( CcCopyReadExceptionFilter( GetExceptionInformation(), &Status ) ) { CcUnpinFileData( Bcb, TRUE, UNPIN ); // // If we got an access violation, then the user buffer went // away. Otherwise we must have gotten an I/O error trying // to bring the data in. // if (Status == STATUS_ACCESS_VIOLATION) { ExRaiseStatus( STATUS_INVALID_USER_BUFFER ); } else { ExRaiseStatus(FsRtlNormalizeNtstatus( Status, STATUS_UNEXPECTED_IO_ERROR )); } } // // Assume we did not get all the data we wanted, and set FOffset // to the end of the returned data and adjust the Buffer and Length. // FOffset = BeyondLastByte; Buffer = (PCHAR)Buffer + ReceivedLength; Length -= ReceivedLength; } DebugTrace(-1, me, "CcCopyWrite -> TRUE\n", 0 ); return TRUE; }

NTKERNELAPI VOID CcDeferWrite (  IN PFILE_OBJECT  FileObject, IN PCC_POST_DEFERRED_WRITE  PostRoutine, IN PVOID  Context1, IN PVOID  Context2, IN ULONG  BytesToWrite, IN BOOLEAN  Retrying )

Definition at line 1982 of file copysup.c. References BooleanFlagOn, _DEFERRED_WRITE::BytesToWrite, CACHE_NTC_DEFERRED_WRITE, CcAcquireMasterLock, CcDeferredWrites, CcDeferredWriteSpinLock, CcPostDeferredWrites(), CcReleaseMasterLock, CcScheduleLazyWriteScan(), _DEFERRED_WRITE::Context1, Context1, _DEFERRED_WRITE::Context2, Context2, DEFERRED_WRITE, _DEFERRED_WRITE::DeferredWriteLinks, _DEFERRED_WRITE::Event, ExAllocatePoolWithTag, ExInterlockedInsertHeadList(), ExInterlockedInsertTailList(), _DEFERRED_WRITE::FileObject, FSRTL_FLAG_LIMIT_MODIFIED_PAGES, LazyWriter, _DEFERRED_WRITE::LimitModifiedPages, _DEFERRED_WRITE::NodeByteSize, _DEFERRED_WRITE::NodeTypeCode, NonPagedPool, NULL, _DEFERRED_WRITE::PostRoutine, and _LAZY_WRITER::ScanActive. : This routine may be called to have the Cache Manager defer posting of a write until the Lazy Writer makes some progress writing, or there are more available pages. A file system would normally call this routine after receiving FALSE from CcCanIWrite, and preparing the request to be posted. Arguments: FileObject - for the file to be written PostRoutine - Address of the PostRoutine that the Cache Manager can call to post the request when conditions are right. Note that it is possible that this routine will be called immediately from this routine. Context1 - First context parameter for the post routine. Context2 - Secont parameter for the post routine. BytesToWrite - Number of bytes that the request is trying to write to the cache. Retrying - Supplied as FALSE if the request is being posted for the first time, TRUE otherwise. Return Value: None --*/ { PDEFERRED_WRITE DeferredWrite; KIRQL OldIrql; // // Attempt to allocate a deferred write block, and if we do not get // one, just post it immediately rather than gobbling up must succeed // pool. // DeferredWrite = ExAllocatePoolWithTag( NonPagedPool, sizeof(DEFERRED_WRITE), 'wDcC' ); if (DeferredWrite == NULL) { (*PostRoutine)( Context1, Context2 ); return; } // // Fill in the block. // DeferredWrite->NodeTypeCode = CACHE_NTC_DEFERRED_WRITE; DeferredWrite->NodeByteSize = sizeof(DEFERRED_WRITE); DeferredWrite->FileObject = FileObject; DeferredWrite->BytesToWrite = BytesToWrite; DeferredWrite->Event = NULL; DeferredWrite->PostRoutine = PostRoutine; DeferredWrite->Context1 = Context1; DeferredWrite->Context2 = Context2; DeferredWrite->LimitModifiedPages = BooleanFlagOn(((PFSRTL_COMMON_FCB_HEADER)(FileObject->FsContext))->Flags, FSRTL_FLAG_LIMIT_MODIFIED_PAGES); // // Now insert at the appropriate end of the list // if (Retrying) { ExInterlockedInsertHeadList( &CcDeferredWrites, &DeferredWrite->DeferredWriteLinks, &CcDeferredWriteSpinLock ); } else { ExInterlockedInsertTailList( &CcDeferredWrites, &DeferredWrite->DeferredWriteLinks, &CcDeferredWriteSpinLock ); } // // Now since we really didn't synchronize anything but the insertion, // we call the post routine to make sure that in some wierd case we // do not leave anyone hanging with no dirty bytes for the Lazy Writer. // CcPostDeferredWrites(); // // Schedule the lazy writer in case the reason we're blocking // is that we're waiting for Mm (or some other external flag) // to lower and let this write happen. He will be the one to // keep coming back and checking if this can proceed, even if // there are no cache manager pages to write. // CcAcquireMasterLock( &OldIrql); if (!LazyWriter.ScanActive) { CcScheduleLazyWriteScan(); } CcReleaseMasterLock( OldIrql); }

NTKERNELAPI VOID CcFastCopyRead (  IN PFILE_OBJECT  FileObject, IN ULONG  FileOffset, IN ULONG  Length, IN ULONG  PageCount, OUT PVOID  Buffer, OUT PIO_STATUS_BLOCK  IoStatus )

Definition at line 588 of file copysup.c. References ASSERT, _VACB::BaseAddress, _PRIVATE_CACHE_MAP::BeyondLastByte1, _PRIVATE_CACHE_MAP::BeyondLastByte2, Buffer, CcCopyReadExceptionFilter(), CcCopyReadWait, CcCopyReadWaitMiss, CcFreeActiveVacb(), CcFreeVirtualAddress(), CcGetVirtualAddress(), CcMissCounter, CcScheduleReadAhead(), CcThrowAway, COMPUTE_PAGES_SPANNED, DebugTrace, ExRaiseStatus(), FALSE, _PRIVATE_CACHE_MAP::FileOffset1, _PRIVATE_CACHE_MAP::FileOffset2, _SHARED_CACHE_MAP::FileSize, FlagOn, FO_RANDOM_ACCESS, FsRtlNormalizeNtstatus(), GetActiveVacb, HOT_STATISTIC, me, MmCheckCachedPageState(), MmResetPageFaultReadAhead, MmSavePageFaultReadAhead, MmSetPageFaultReadAhead, _SHARED_CACHE_MAP::NeedToZero, NTSTATUS(), NULL, PAGE_SHIFT, PsGetCurrentThread, _PRIVATE_CACHE_MAP::ReadAheadEnabled, _PRIVATE_CACHE_MAP::ReadAheadLength, ROUND_TO_PAGES, SetActiveVacb, Status, TRUE, VACB_MAPPING_GRANULARITY, and VACB_OFFSET_SHIFT. Referenced by FsRtlCopyRead(). : This routine attempts to copy the specified file data from the cache into the output buffer, and deliver the correct I/O status. This is a faster version of CcCopyRead which only supports 32-bit file offsets and synchronicity (Wait = TRUE). 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. PageCount - Number of pages spanned by the read. Buffer - Pointer to output buffer to which data should be copied. IoStatus - Pointer to standard I/O status block to receive the status for the transfer. (STATUS_SUCCESS guaranteed for cache hits, otherwise the actual I/O status is returned.) Note that even if FALSE is returned, the IoStatus.Information field will return the count of any bytes successfully transferred before a blocking condition occured. The caller may either choose to ignore this information, or resume the copy later accounting for bytes transferred. Return Value: None --*/ { PSHARED_CACHE_MAP SharedCacheMap; PPRIVATE_CACHE_MAP PrivateCacheMap; PVOID CacheBuffer; LARGE_INTEGER FOffset; PVACB Vacb; PVACB ActiveVacb; ULONG ActivePage; ULONG PageIsDirty; ULONG SavedState; ULONG PagesToGo; ULONG MoveLength; ULONG LengthToGo; KIRQL OldIrql; NTSTATUS Status; LARGE_INTEGER OriginalOffset; ULONG OriginalLength = Length; PETHREAD Thread = PsGetCurrentThread(); ULONG GotAMiss = 0; DebugTrace(+1, me, "CcFastCopyRead\n", 0 ); MmSavePageFaultReadAhead( Thread, &SavedState ); // // Get pointer to shared and private cache maps // SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; PrivateCacheMap = FileObject->PrivateCacheMap; // // Check for read past file size, the caller must filter this case out. // ASSERT( (FileOffset + Length) <= SharedCacheMap->FileSize.LowPart ); // // If read ahead is enabled, then do the read ahead here so it // overlaps with the copy (otherwise we will do it below). // Note that we are assuming that we will not get ahead of our // current transfer - if read ahead is working it should either // already be in memory or else underway. // OriginalOffset.LowPart = FileOffset; OriginalOffset.HighPart = 0; if (PrivateCacheMap->ReadAheadEnabled && (PrivateCacheMap->ReadAheadLength[1] == 0)) { CcScheduleReadAhead( FileObject, &OriginalOffset, Length ); } // // This is not an exact solution, but when IoPageRead gets a miss, // it cannot tell whether it was CcCopyRead or CcMdlRead, but since // the miss should occur very soon, by loading the pointer here // probably the right counter will get incremented, and in any case, // we hope the errrors average out! // CcMissCounter = &CcCopyReadWaitMiss; // // Increment performance counters // HOT_STATISTIC(CcCopyReadWait) += 1; // // See if we have an active Vacb, that we can just copy to. // GetActiveVacb( SharedCacheMap, OldIrql, ActiveVacb, ActivePage, PageIsDirty ); if (ActiveVacb != NULL) { if ((FileOffset >> VACB_OFFSET_SHIFT) == (ActivePage >> (VACB_OFFSET_SHIFT - PAGE_SHIFT))) { ULONG LengthToCopy = VACB_MAPPING_GRANULARITY - (FileOffset & (VACB_MAPPING_GRANULARITY - 1)); if (SharedCacheMap->NeedToZero != NULL) { CcFreeActiveVacb( SharedCacheMap, NULL, 0, FALSE ); } // // Get the starting point in the view. // CacheBuffer = (PVOID)((PCHAR)ActiveVacb->BaseAddress + (FileOffset & (VACB_MAPPING_GRANULARITY - 1))); // // Reduce LengthToCopy if it is greater than our caller's length. // if (LengthToCopy > Length) { LengthToCopy = Length; } // // Like the logic for the normal case below, we want to spin around // making sure Mm only reads the pages we will need. // PagesToGo = COMPUTE_PAGES_SPANNED( CacheBuffer, LengthToCopy ) - 1; // // Copy the data to the user buffer. // try { if (PagesToGo != 0) { LengthToGo = LengthToCopy; while (LengthToGo != 0) { MoveLength = (ULONG)((PCHAR)(ROUND_TO_PAGES(((PCHAR)CacheBuffer + 1))) - (PCHAR)CacheBuffer); if (MoveLength > LengthToGo) { MoveLength = LengthToGo; } // // Here's hoping that it is cheaper to call Mm to see if // the page is valid. If not let Mm know how many pages // we are after before doing the move. // MmSetPageFaultReadAhead( Thread, PagesToGo ); GotAMiss |= !MmCheckCachedPageState( CacheBuffer, FALSE ); RtlCopyBytes( Buffer, CacheBuffer, MoveLength ); PagesToGo -= 1; LengthToGo -= MoveLength; Buffer = (PCHAR)Buffer + MoveLength; CacheBuffer = (PCHAR)CacheBuffer + MoveLength; } // // Handle the read here that stays on a single page. // } else { // // Here's hoping that it is cheaper to call Mm to see if // the page is valid. If not let Mm know how many pages // we are after before doing the move. // MmSetPageFaultReadAhead( Thread, 0 ); GotAMiss |= !MmCheckCachedPageState( CacheBuffer, FALSE ); RtlCopyBytes( Buffer, CacheBuffer, LengthToCopy ); Buffer = (PCHAR)Buffer + LengthToCopy; } } except( CcCopyReadExceptionFilter( GetExceptionInformation(), &Status ) ) { MmResetPageFaultReadAhead( Thread, SavedState ); SetActiveVacb( SharedCacheMap, OldIrql, ActiveVacb, ActivePage, PageIsDirty ); // // If we got an access violation, then the user buffer went // away. Otherwise we must have gotten an I/O error trying // to bring the data in. // if (Status == STATUS_ACCESS_VIOLATION) { ExRaiseStatus( STATUS_INVALID_USER_BUFFER ); } else { ExRaiseStatus( FsRtlNormalizeNtstatus( Status, STATUS_UNEXPECTED_IO_ERROR )); } } // // Now adjust FileOffset and Length by what we copied. // FileOffset += LengthToCopy; Length -= LengthToCopy; } // // If that was all the data, then remember the Vacb // if (Length == 0) { SetActiveVacb( SharedCacheMap, OldIrql, ActiveVacb, ActivePage, PageIsDirty ); // // Otherwise we must free it because we will map other vacbs below. // } else { CcFreeActiveVacb( SharedCacheMap, ActiveVacb, ActivePage, PageIsDirty ); } } // // Not all of the transfer will come back at once, so we have to loop // until the entire transfer is complete. // FOffset.HighPart = 0; FOffset.LowPart = FileOffset; while (Length != 0) { ULONG ReceivedLength; ULONG BeyondLastByte; // // Call local routine to Map or Access the file data, then move the data, // then call another local routine to free the data. If we cannot map // the data because of a Wait condition, return FALSE. // // Note that this call may result in an exception, however, if it // does no Bcb is returned and this routine has absolutely no // cleanup to perform. Therefore, we do not have a try-finally // and we allow the possibility that we will simply be unwound // without notice. // CacheBuffer = CcGetVirtualAddress( SharedCacheMap, FOffset, &Vacb, &ReceivedLength ); BeyondLastByte = FOffset.LowPart + ReceivedLength; // // If we got more than we need, make sure to only transfer // the right amount. // if (ReceivedLength > Length) { ReceivedLength = Length; } // // It is possible for the user buffer to become no longer accessible // since it was last checked by the I/O system. If we fail to access // the buffer we must raise a status that the caller's exception // filter considers as "expected". Also we unmap the Bcb here, since // we otherwise would have no other reason to put a try-finally around // this loop. // try { PagesToGo = COMPUTE_PAGES_SPANNED( CacheBuffer, ReceivedLength ) - 1; // // We know exactly how much we want to read here, and we do not // want to read any more in case the caller is doing random access. // Our read ahead logic takes care of detecting sequential reads, // and tends to do large asynchronous read aheads. So far we have // only mapped the data and we have not forced any in. What we // do now is get into a loop where we copy a page at a time and // just prior to each move, we tell MM how many additional pages // we would like to have read in, in the event that we take a // fault. With this strategy, for cache hits we never make a single // expensive call to MM to guarantee that the data is in, yet if we // do take a fault, we are guaranteed to only take one fault because // we will read all of the data in for the rest of the transfer. // // We test first for the multiple page case, to keep the small // reads faster. // if (PagesToGo != 0) { LengthToGo = ReceivedLength; while (LengthToGo != 0) { MoveLength = (ULONG)((PCHAR)(ROUND_TO_PAGES(((PCHAR)CacheBuffer + 1))) - (PCHAR)CacheBuffer); if (MoveLength > LengthToGo) { MoveLength = LengthToGo; } // // Here's hoping that it is cheaper to call Mm to see if // the page is valid. If not let Mm know how many pages // we are after before doing the move. // MmSetPageFaultReadAhead( Thread, PagesToGo ); GotAMiss |= !MmCheckCachedPageState( CacheBuffer, FALSE ); RtlCopyBytes( Buffer, CacheBuffer, MoveLength ); PagesToGo -= 1; LengthToGo -= MoveLength; Buffer = (PCHAR)Buffer + MoveLength; CacheBuffer = (PCHAR)CacheBuffer + MoveLength; } // // Handle the read here that stays on a single page. // } else { // // Here's hoping that it is cheaper to call Mm to see if // the page is valid. If not let Mm know how many pages // we are after before doing the move. // MmSetPageFaultReadAhead( Thread, 0 ); GotAMiss |= !MmCheckCachedPageState( CacheBuffer, FALSE ); RtlCopyBytes( Buffer, CacheBuffer, ReceivedLength ); Buffer = (PCHAR)Buffer + ReceivedLength; } } except( CcCopyReadExceptionFilter( GetExceptionInformation(), &Status ) ) { CcMissCounter = &CcThrowAway; // // If we get an exception, then we have to renable page fault // clustering and unmap on the way out. // MmResetPageFaultReadAhead( Thread, SavedState ); CcFreeVirtualAddress( Vacb ); // // If we got an access violation, then the user buffer went // away. Otherwise we must have gotten an I/O error trying // to bring the data in. // if (Status == STATUS_ACCESS_VIOLATION) { ExRaiseStatus( STATUS_INVALID_USER_BUFFER ); } else { ExRaiseStatus( FsRtlNormalizeNtstatus( Status, STATUS_UNEXPECTED_IO_ERROR )); } } // // Update number of bytes transferred. // Length -= ReceivedLength; // // Unmap the data now, and calculate length left to transfer. // if (Length != 0) { // // If there is more to go, just free this vacb. // CcFreeVirtualAddress( Vacb ); } else { // // Otherwise save it for the next time through. // SetActiveVacb( SharedCacheMap, OldIrql, Vacb, (FOffset.LowPart >> PAGE_SHIFT), 0 ); break; } // // Assume we did not get all the data we wanted, and set FOffset // to the end of the returned data. // FOffset.LowPart = BeyondLastByte; } MmResetPageFaultReadAhead( Thread, SavedState ); CcMissCounter = &CcThrowAway; // // Now enable read ahead if it looks like we got any misses, and do // the first one. // if (GotAMiss && !FlagOn( FileObject->Flags, FO_RANDOM_ACCESS ) && !PrivateCacheMap->ReadAheadEnabled) { PrivateCacheMap->ReadAheadEnabled = TRUE; CcScheduleReadAhead( FileObject, &OriginalOffset, OriginalLength ); } // // Now that we have described our desired read ahead, let's // shift the read history down. // PrivateCacheMap->FileOffset1.LowPart = PrivateCacheMap->FileOffset2.LowPart; PrivateCacheMap->BeyondLastByte1.LowPart = PrivateCacheMap->BeyondLastByte2.LowPart; PrivateCacheMap->FileOffset2.LowPart = OriginalOffset.LowPart; PrivateCacheMap->BeyondLastByte2.LowPart = OriginalOffset.LowPart + OriginalLength; IoStatus->Status = STATUS_SUCCESS; IoStatus->Information = OriginalLength; DebugTrace(-1, me, "CcFastCopyRead -> VOID\n", 0 ); }

NTKERNELAPI VOID CcFastCopyWrite (  IN PFILE_OBJECT  FileObject, IN ULONG  FileOffset, IN ULONG  Length, IN PVOID  Buffer )

Definition at line 1482 of file copysup.c. References ACTIVE_PAGE_IS_DIRTY, _SHARED_CACHE_MAP::ActiveVacbSpinLock, ASSERT, _VACB::BaseAddress, BooleanFlagOn, Buffer, CcCopyReadExceptionFilter(), CcFreeActiveVacb(), CcMapAndCopy(), DebugTrace, ExRaiseStatus(), FALSE, FlagOn, FO_WRITE_THROUGH, FsRtlNormalizeNtstatus(), GetActiveVacb, me, _SHARED_CACHE_MAP::NeedToZero, _SHARED_CACHE_MAP::NeedToZeroVacb, NTSTATUS(), NULL, PAGE_SHIFT, PAGE_SIZE, SetActiveVacb, Status, VACB_MAPPING_GRANULARITY, ZERO_FIRST_PAGE, ZERO_LAST_PAGE, and ZERO_MIDDLE_PAGES. Referenced by FsRtlCopyWrite(). : This routine attempts to copy the specified file data from the specified buffer into the Cache, and deliver the correct I/O status. This is a faster version of CcCopyWrite which only supports 32-bit file offsets and synchronicity (Wait = TRUE) and no Write Through. 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 to receive the data. Length - Length of data in bytes. Buffer - Pointer to input buffer from which data should be copied. Return Value: None Raises: STATUS_INSUFFICIENT_RESOURCES - If a pool allocation failure occurs. This can only occur if Wait was specified as TRUE. (If Wait is specified as FALSE, and an allocation failure occurs, this routine simply returns FALSE.) --*/ { PSHARED_CACHE_MAP SharedCacheMap; PVOID CacheBuffer; PVACB ActiveVacb; ULONG ActivePage; PVOID ActiveAddress; ULONG PageIsDirty; KIRQL OldIrql; NTSTATUS Status; ULONG ZeroFlags; ULONG ValidDataLength; LARGE_INTEGER FOffset; DebugTrace(+1, me, "CcFastCopyWrite\n", 0 ); // // Get pointer to shared cache map and a copy of valid data length // SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; // // See if we have an active Vacb, that we can just copy to. // GetActiveVacb( SharedCacheMap, OldIrql, ActiveVacb, ActivePage, PageIsDirty ); if (ActiveVacb != NULL) { // // See if the request starts in the ActivePage. WriteThrough requests must // go the longer route through CcMapAndCopy, where WriteThrough flushes are // implemented. // if (((FileOffset >> PAGE_SHIFT) == ActivePage) && (Length != 0) && !FlagOn( FileObject->Flags, FO_WRITE_THROUGH )) { ULONG LengthToCopy = PAGE_SIZE - (FileOffset & (PAGE_SIZE - 1)); // // Reduce LengthToCopy if it is greater than our caller's length. // if (LengthToCopy > Length) { LengthToCopy = Length; } // // Copy the data to the user buffer. // try { // // If we are copying to a page that is locked down, then // we have to do it under our spinlock, and update the // NeedToZero field. // OldIrql = 0xFF; CacheBuffer = (PVOID)((PCHAR)ActiveVacb->BaseAddress + (FileOffset & (VACB_MAPPING_GRANULARITY - 1))); if (SharedCacheMap->NeedToZero != NULL) { // // The FastLock may not write our "flag". // OldIrql = 0; ExAcquireFastLock( &SharedCacheMap->ActiveVacbSpinLock, &OldIrql ); // // Note that the NeedToZero could be cleared, since we // tested it without the spinlock. // ActiveAddress = SharedCacheMap->NeedToZero; if ((ActiveAddress != NULL) && (ActiveVacb == SharedCacheMap->NeedToZeroVacb) && (((PCHAR)CacheBuffer + LengthToCopy) > (PCHAR)ActiveAddress)) { // // If we are skipping some bytes in the page, then we need // to zero them. // if ((PCHAR)CacheBuffer > (PCHAR)ActiveAddress) { RtlZeroMemory( ActiveAddress, (PCHAR)CacheBuffer - (PCHAR)ActiveAddress ); } SharedCacheMap->NeedToZero = (PVOID)((PCHAR)CacheBuffer + LengthToCopy); } ExReleaseFastLock( &SharedCacheMap->ActiveVacbSpinLock, OldIrql ); } RtlCopyBytes( CacheBuffer, Buffer, LengthToCopy ); } except( CcCopyReadExceptionFilter( GetExceptionInformation(), &Status ) ) { // // If we failed to overwrite the uninitialized data, // zero it now (we cannot safely restore NeedToZero). // if (OldIrql != 0xFF) { RtlZeroBytes( CacheBuffer, LengthToCopy ); } SetActiveVacb( SharedCacheMap, OldIrql, ActiveVacb, ActivePage, ACTIVE_PAGE_IS_DIRTY ); // // If we got an access violation, then the user buffer went // away. Otherwise we must have gotten an I/O error trying // to bring the data in. // if (Status == STATUS_ACCESS_VIOLATION) { ExRaiseStatus( STATUS_INVALID_USER_BUFFER ); } else { ExRaiseStatus( FsRtlNormalizeNtstatus( Status, STATUS_UNEXPECTED_IO_ERROR )); } } // // Now adjust FileOffset and Length by what we copied. // Buffer = (PVOID)((PCHAR)Buffer + LengthToCopy); FileOffset += LengthToCopy; Length -= LengthToCopy; // // If that was all the data, then get outski... // if (Length == 0) { SetActiveVacb( SharedCacheMap, OldIrql, ActiveVacb, ActivePage, ACTIVE_PAGE_IS_DIRTY ); return; } // // Remember that the page is dirty now. // PageIsDirty |= ACTIVE_PAGE_IS_DIRTY; } CcFreeActiveVacb( SharedCacheMap, ActiveVacb, ActivePage, PageIsDirty ); // // Else someone else could have the active page, and may want to zero // the range we plan to write! // } else if (SharedCacheMap->NeedToZero != NULL) { CcFreeActiveVacb( SharedCacheMap, NULL, 0, FALSE ); } // // Set up for call to CcMapAndCopy // FOffset.LowPart = FileOffset; FOffset.HighPart = 0; ValidDataLength = ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->ValidDataLength.LowPart; ASSERT((ValidDataLength == MAXULONG) || (((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->ValidDataLength.HighPart == 0)); // // At this point we can calculate the ReadOnly flag for // the purposes of whether to use the Bcb resource, and // we can calculate the ZeroFlags. // // // We can always zero middle pages, if any. // ZeroFlags = ZERO_MIDDLE_PAGES; if (((FileOffset & (PAGE_SIZE - 1)) == 0) && (Length >= PAGE_SIZE)) { ZeroFlags |= ZERO_FIRST_PAGE; } if (((FileOffset + Length) & (PAGE_SIZE - 1)) == 0) { ZeroFlags |= ZERO_LAST_PAGE; } if ((FileOffset & ~(PAGE_SIZE - 1)) >= ValidDataLength) { ZeroFlags |= ZERO_FIRST_PAGE | ZERO_MIDDLE_PAGES | ZERO_LAST_PAGE; } else if (((FileOffset & ~(PAGE_SIZE - 1)) + PAGE_SIZE) >= ValidDataLength) { ZeroFlags |= ZERO_MIDDLE_PAGES | ZERO_LAST_PAGE; } // // Call a routine to map and copy the data in Mm and get out. // CcMapAndCopy( SharedCacheMap, Buffer, &FOffset, Length, ZeroFlags, BooleanFlagOn( FileObject->Flags, FO_WRITE_THROUGH )); DebugTrace(-1, me, "CcFastCopyWrite -> VOID\n", 0 ); }

NTKERNELAPI VOID CcFlushCache (  IN PSECTION_OBJECT_POINTERS  SectionObjectPointer, IN PLARGE_INTEGER FileOffset  OPTIONAL, IN ULONG  Length, OUT PIO_STATUS_BLOCK IoStatus  OPTIONAL )

Definition at line 4411 of file cachesub.c. References _SHARED_CACHE_MAP::ActivePage, _SHARED_CACHE_MAP::ActiveVacb, CC_REQUEUE, CcAcquireByteRangeForWrite(), CcAcquireMasterLock, CcDecrementOpenCount, CcDeferredWrites, CcDirtySharedCacheMapList, CcExceptionFilter(), CcFreeActiveVacb(), CcFreeVirtualAddress(), CcGetVirtualAddressIfMapped(), CcIdleDelayTick, CcIncrementOpenCount, CcLazyWriteHotSpots, CcLazyWriteIos, CcLazyWritePages, CcNoDelay, CcPostDeferredWrites(), CcReleaseByteRangeFromWrite(), CcReleaseMasterLock, CcScheduleLazyWriteScan(), DebugTrace, DebugTrace2, _SHARED_CACHE_MAP::DirtyPages, FALSE, _SHARED_CACHE_MAP::FileObject, _SHARED_CACHE_MAP::FileSize, FlagOn, _SHARED_CACHE_MAP::Flags, _FILE_OBJECT::FsContext, FSRTL_FLAG_USER_MAPPED_FILE, GetActiveVacbAtDpcLevel, KeQueryTickCount(), LAZY_WRITE_OCCURRED, _SHARED_CACHE_MAP::LazyWritePassCount, LazyWriter, me, mm, MmFlushSection(), MmSetAddressRangeModified(), MODIFIED_WRITE_DISABLED, _SHARED_CACHE_MAP::NeedToZero, _SHARED_CACHE_MAP::NeedToZeroPage, NT_SUCCESS, NTSTATUS(), NULL, Offset, _SHARED_CACHE_MAP::OpenCount, _LAZY_WRITER::OtherWork, PAGE_SHIFT, PAGE_SIZE, _SHARED_CACHE_MAP::PagesToWrite, PFSRTL_COMMON_FCB_HEADER, PIN_ACCESS, RetryError, _LAZY_WRITER::ScanActive, _FILE_OBJECT::SectionObjectPointer, SetFlag, _SHARED_CACHE_MAP_LIST_CURSOR::SharedCacheMapLinks, _SHARED_CACHE_MAP::SharedCacheMapLinks, Status, TRUE, _SHARED_CACHE_MAP::ValidDataGoal, _SHARED_CACHE_MAP::ValidDataLength, and WRITE_QUEUED. Referenced by CcWriteBehind(), CcZeroEndOfLastPage(), LfsFlushLfcb(), LfsFlushLogPage(), and MiFlushDataSection(). : This routine may be called to flush dirty data from the cache to the cached file on disk. Any byte range within the file may be flushed, or the entire file may be flushed by omitting the FileOffset parameter. This routine does not take a Wait parameter; the caller should assume that it will always block. Arguments: SectionObjectPointer - A pointer to the Section Object Pointers structure in the nonpaged Fcb. FileOffset - If this parameter is supplied (not NULL), then only the byte range specified by FileOffset and Length are flushed. If &CcNoDelay is specified, then this signifies the call from the Lazy Writer, and the lazy write scan should resume as normal from the last spot where it left off in the file. Length - Defines the length of the byte range to flush, starting at FileOffset. This parameter is ignored if FileOffset is specified as NULL. IoStatus - The I/O status resulting from the flush operation. Return Value: None. --*/ { LARGE_INTEGER NextFileOffset, TargetOffset; ULONG NextLength; PBCB FirstBcb; KIRQL OldIrql; PSHARED_CACHE_MAP SharedCacheMap; IO_STATUS_BLOCK TrashStatus; PVOID TempVa; ULONG RemainingLength, TempLength; NTSTATUS PopupStatus; BOOLEAN HotSpot; ULONG BytesWritten = 0; BOOLEAN PopupRequired = FALSE; BOOLEAN VerifyRequired = FALSE; BOOLEAN IsLazyWriter = FALSE; BOOLEAN FreeActiveVacb = FALSE; PVACB ActiveVacb = NULL; NTSTATUS Status = STATUS_SUCCESS; LARGE_INTEGER EndTick, CurrentTick; DebugTrace(+1, me, "CcFlushCache:\n", 0 ); DebugTrace( 0, mm, " SectionObjectPointer = %08lx\n", SectionObjectPointer ); DebugTrace2(0, me, " FileOffset = %08lx, %08lx\n", ARGUMENT_PRESENT(FileOffset) ? FileOffset->LowPart : 0, ARGUMENT_PRESENT(FileOffset) ? FileOffset->HighPart : 0 ); DebugTrace( 0, me, " Length = %08lx\n", Length ); // // If IoStatus passed a Null pointer, set up to through status away. // if (!ARGUMENT_PRESENT(IoStatus)) { IoStatus = &TrashStatus; } IoStatus->Status = STATUS_SUCCESS; IoStatus->Information = 0; // // See if this is the Lazy Writer. Since he wants to use this common // routine, which is also a public routine callable by file systems, // the Lazy Writer shows his call by specifying CcNoDelay as the file offset! // // Also, in case we do not write anything because we see only HotSpot(s), // initialize the Status to indicate a retryable error, so CcWorkerThread // knows we did not make any progress. Of course any actual flush will // overwrite this code. // if (FileOffset == &CcNoDelay) { IoStatus->Status = STATUS_VERIFY_REQUIRED; IsLazyWriter = TRUE; FileOffset = NULL; } // // If there is nothing to do, return here. // if (ARGUMENT_PRESENT(FileOffset) && (Length == 0)) { DebugTrace(-1, me, "CcFlushCache -> VOID\n", 0 ); return; } // // See if the file is cached. // CcAcquireMasterLock( &OldIrql ); SharedCacheMap = SectionObjectPointer->SharedCacheMap; if (SharedCacheMap != NULL) { // // Increment the open count to keep it from going away. // CcIncrementOpenCount( SharedCacheMap, 'fcCS' ); if ((SharedCacheMap->NeedToZero != NULL) || (SharedCacheMap->ActiveVacb != NULL)) { ULONG FirstPage = 0; ULONG LastPage = MAXULONG; if (ARGUMENT_PRESENT(FileOffset)) { FirstPage = (ULONG)(FileOffset->QuadPart >> PAGE_SHIFT); LastPage = (ULONG)((FileOffset->QuadPart + Length - 1) >> PAGE_SHIFT); } // // Make sure we do not flush the active page without zeroing any // uninitialized data. Also, it is very important to free the active // page if it is the one to be flushed, so that we get the dirty // bit out to the Pfn. // if (((((LONGLONG)LastPage + 1) << PAGE_SHIFT) > SharedCacheMap->ValidDataGoal.QuadPart) || ((SharedCacheMap->NeedToZero != NULL) && (FirstPage <= SharedCacheMap->NeedToZeroPage) && (LastPage >= SharedCacheMap->NeedToZeroPage)) || ((SharedCacheMap->ActiveVacb != NULL) && (FirstPage <= SharedCacheMap->ActivePage) && (LastPage >= SharedCacheMap->ActivePage))) { GetActiveVacbAtDpcLevel( SharedCacheMap, ActiveVacb, RemainingLength, TempLength ); FreeActiveVacb = TRUE; } } } CcReleaseMasterLock( OldIrql ); if (FreeActiveVacb) { CcFreeActiveVacb( SharedCacheMap, ActiveVacb, RemainingLength, TempLength ); } // // If there is a user-mapped file, then we perform the "service" of // flushing even data not written via the file system. Note that this // is pretty important for folks provoking the flush/purge of a coherency // operation. // // It is critical this happen before we examine our own hints. In the course // of this flush it is possible valid data length will be advanced by the // underlying filesystem, with CcZero'ing behind - which will cause us to // make some dirty zeroes in the cache. Syscache bug! Note how coherency // flushing works ... // if ((SharedCacheMap == NULL) || FlagOn(((PFSRTL_COMMON_FCB_HEADER)(SharedCacheMap->FileObject->FsContext))->Flags, FSRTL_FLAG_USER_MAPPED_FILE) && !IsLazyWriter) { // // Call MM to flush the section through our view. // DebugTrace( 0, mm, "MmFlushSection:\n", 0 ); DebugTrace( 0, mm, " SectionObjectPointer = %08lx\n", SectionObjectPointer ); DebugTrace2(0, me, " FileOffset = %08lx, %08lx\n", ARGUMENT_PRESENT(FileOffset) ? FileOffset->LowPart : 0, ARGUMENT_PRESENT(FileOffset) ? FileOffset->HighPart : 0 ); DebugTrace( 0, mm, " RegionSize = %08lx\n", Length ); try { Status = MmFlushSection( SectionObjectPointer, FileOffset, Length, IoStatus, TRUE ); } except( CcExceptionFilter( IoStatus->Status = GetExceptionCode() )) { KdPrint(("CACHE MANAGER: MmFlushSection raised %08lx\n", IoStatus->Status)); } if ((!NT_SUCCESS(IoStatus->Status)) && !RetryError(IoStatus->Status)) { PopupRequired = TRUE; PopupStatus = IoStatus->Status; } DebugTrace2(0, mm, " <IoStatus = %08lx, %08lx\n", IoStatus->Status, IoStatus->Information ); } // // Scan for dirty pages if there is a shared cache map. // if (SharedCacheMap != NULL) { // // If FileOffset was not specified then set to flush entire region // and set valid data length to the goal so that we will not get // any more call backs. // if (!IsLazyWriter && !ARGUMENT_PRESENT(FileOffset)) { SharedCacheMap->ValidDataLength = SharedCacheMap->ValidDataGoal; } // // If this is an explicit flush, initialize our offset to scan for. // if (ARGUMENT_PRESENT(FileOffset)) { TargetOffset = *FileOffset; } // // Assume we want to pass the explicit flush flag in Length. // But overwrite it if a length really was specified. On // subsequent loops, NextLength will have some nonzero value. // NextLength = 1; if (Length != 0) { NextLength = Length; } // // Now calculate the tick that will signal the expiration of a // lazy writer tick interval. // if (IsLazyWriter) { KeQueryTickCount( &EndTick ); EndTick.QuadPart += CcIdleDelayTick; } // // Loop as long as we find buffers to flush for this // SharedCacheMap, and we are not trying to delete the guy. // while (((SharedCacheMap->PagesToWrite != 0) || !IsLazyWriter) && ((SharedCacheMap->FileSize.QuadPart != 0) || FlagOn(SharedCacheMap->Flags, PIN_ACCESS)) && !VerifyRequired && CcAcquireByteRangeForWrite ( SharedCacheMap, IsLazyWriter ? NULL : (ARGUMENT_PRESENT(FileOffset) ? &TargetOffset : NULL), IsLazyWriter ? 0: NextLength, &NextFileOffset, &NextLength, &FirstBcb )) { // // Assume this range is not a hot spot. // HotSpot = FALSE; // // We defer calling Mm to set address range modified until here, to take // overhead out of the main line path, and to reduce the number of TBIS // on a multiprocessor. // RemainingLength = NextLength; do { // // See if the next file offset is mapped. (If not, the dirty bit // was propagated on the unmap.) // if ((TempVa = CcGetVirtualAddressIfMapped( SharedCacheMap, NextFileOffset.QuadPart + NextLength - RemainingLength, &ActiveVacb, &TempLength)) != NULL) { // // Reduce TempLength to RemainingLength if necessary, and // call MM. // if (TempLength > RemainingLength) { TempLength = RemainingLength; } // // Clear the Dirty bit (if set) in the PTE and set the // Pfn modified. Assume if the Pte was dirty, that this may // be a hot spot. Do not do hot spots for metadata, and unless // they are within ValidDataLength as reported to the file system // via CcSetValidData. // HotSpot = (BOOLEAN)((MmSetAddressRangeModified(TempVa, TempLength) || HotSpot) && ((NextFileOffset.QuadPart + NextLength) < (SharedCacheMap->ValidDataLength.QuadPart)) && ((SharedCacheMap->LazyWritePassCount & 0xF) != 0) && IsLazyWriter) && !FlagOn(SharedCacheMap->Flags, MODIFIED_WRITE_DISABLED); CcFreeVirtualAddress( ActiveVacb ); } else { // // Reduce TempLength to RemainingLength if necessary. // if (TempLength > RemainingLength) { TempLength = RemainingLength; } } // // Reduce RemainingLength by what we processed. // RemainingLength -= TempLength; // // Loop until done. // } while (RemainingLength != 0); CcLazyWriteHotSpots += HotSpot; // // Now flush, now flush if we do not think it is a hot spot. // if (!HotSpot) { MmFlushSection( SharedCacheMap->FileObject->SectionObjectPointer, &NextFileOffset, NextLength, IoStatus, !IsLazyWriter ); if (NT_SUCCESS(IoStatus->Status)) { if (!FlagOn(SharedCacheMap->Flags, LAZY_WRITE_OCCURRED)) { CcAcquireMasterLock( &OldIrql ); SetFlag(SharedCacheMap->Flags, LAZY_WRITE_OCCURRED); CcReleaseMasterLock( OldIrql ); } // // Increment performance counters // if (IsLazyWriter) { CcLazyWriteIos += 1; CcLazyWritePages += (NextLength + PAGE_SIZE - 1) >> PAGE_SHIFT; } } else { LARGE_INTEGER Offset = NextFileOffset; ULONG RetryLength = NextLength; DebugTrace2( 0, 0, "I/O Error on Cache Flush: %08lx, %08lx\n", IoStatus->Status, IoStatus->Information ); if (RetryError(IoStatus->Status)) { VerifyRequired = TRUE; // // Loop to write each page individually, starting with one // more try on the page that got the error, in case that page // or any page beyond it can be successfully written // individually. Note that Offset and RetryLength are // guaranteed to be in integral pages, but the Information // field from the failed request is not. // // We ignore errors now, and give it one last shot, before // setting the pages clean (see below). // } else { do { DebugTrace2( 0, 0, "Trying page at offset %08lx, %08lx\n", Offset.LowPart, Offset.HighPart ); MmFlushSection ( SharedCacheMap->FileObject->SectionObjectPointer, &Offset, PAGE_SIZE, IoStatus, !IsLazyWriter ); DebugTrace2( 0, 0, "I/O status = %08lx, %08lx\n", IoStatus->Status, IoStatus->Information ); if (NT_SUCCESS(IoStatus->Status)) { CcAcquireMasterLock( &OldIrql ); SetFlag(SharedCacheMap->Flags, LAZY_WRITE_OCCURRED); CcReleaseMasterLock( OldIrql ); } if ((!NT_SUCCESS(IoStatus->Status)) && !RetryError(IoStatus->Status)) { PopupRequired = TRUE; PopupStatus = IoStatus->Status; } VerifyRequired = VerifyRequired || RetryError(IoStatus->Status); Offset.QuadPart = Offset.QuadPart + (LONGLONG)PAGE_SIZE; RetryLength -= PAGE_SIZE; } while(RetryLength > 0); } } } // // Now release the Bcb resources and set them clean. Note we do not check // here for errors, and just returned in the I/O status. Errors on writes // are rare to begin with. Nonetheless, our strategy is to rely on // one or more of the following (depending on the file system) to prevent // errors from getting to us. // // - Retries and/or other forms of error recovery in the disk driver // - Mirroring driver // - Hot fixing in the noncached path of the file system // // In the unexpected case that a write error does get through, we // *currently* just set the Bcbs clean anyway, rather than let // Bcbs and pages accumulate which cannot be written. Note we did // a popup above to at least notify the guy. // // Set the pages dirty again if we either saw a HotSpot or got // verify required. // CcReleaseByteRangeFromWrite ( SharedCacheMap, &NextFileOffset, NextLength, FirstBcb, (BOOLEAN)(HotSpot || VerifyRequired) ); // // See if there is any deferred writes we should post. // BytesWritten += NextLength; if ((BytesWritten >= 0x40000) && !IsListEmpty(&CcDeferredWrites)) { CcPostDeferredWrites(); BytesWritten = 0; } // // If we're the lazy writer and have spent more than the active tick // length in this loop, break out for a requeue so we share the // file resources. // if (IsLazyWriter) { KeQueryTickCount( &CurrentTick ); // // Note that CcIdleDelay is a relative (negative) timestamp. // if (CurrentTick.QuadPart > EndTick.QuadPart) { IoStatus->Information = CC_REQUEUE; break; } } // // Now for explicit flushes, we should advance our range. // if (ARGUMENT_PRESENT(FileOffset)) { NextFileOffset.QuadPart += NextLength; // // Done yet? // if ((FileOffset->QuadPart + Length) <= NextFileOffset.QuadPart) { break; } // // Calculate new target range // NextLength = (ULONG)((FileOffset->QuadPart + Length) - NextFileOffset.QuadPart); TargetOffset = NextFileOffset; } } } // // See if there are any deferred writes we should post if // we escaped the loop without checking after a series of // flushes. // if (BytesWritten != 0 && !IsListEmpty(&CcDeferredWrites)) { CcPostDeferredWrites(); } // // Now we can get rid of the open count, and clean up as required. // if (SharedCacheMap != NULL) { // // Serialize again to decrement the open count. // CcAcquireMasterLock( &OldIrql ); CcDecrementOpenCount( SharedCacheMap, 'fcCF' ); if ((SharedCacheMap->OpenCount == 0) && !FlagOn(SharedCacheMap->Flags, WRITE_QUEUED) && (SharedCacheMap->DirtyPages == 0)) { // // Move to the dirty list. // RemoveEntryList( &SharedCacheMap->SharedCacheMapLinks ); InsertTailList( &CcDirtySharedCacheMapList.SharedCacheMapLinks, &SharedCacheMap->SharedCacheMapLinks ); // // Make sure the Lazy Writer will wake up, because we // want him to delete this SharedCacheMap. // LazyWriter.OtherWork = TRUE; if (!LazyWriter.ScanActive) { CcScheduleLazyWriteScan(); } } CcReleaseMasterLock( OldIrql ); } // // Make sure and return the first error to our caller. In the // case of the Lazy Writer, a popup will be issued. // if (PopupRequired) { IoStatus->Status = PopupStatus; } // // Let the Lazy writer know if we did anything, so he can DebugTrace(-1, me, "CcFlushCache -> VOID\n", 0 ); return; }

NTKERNELAPI LARGE_INTEGER CcGetDirtyPages (  IN PVOID  LogHandle, IN PDIRTY_PAGE_ROUTINE  DirtyPageRoutine, IN PVOID  Context1, IN PVOID  Context2 )

Definition at line 142 of file logsup.c. References _BCB::BcbLinks, _SHARED_CACHE_MAP::BcbList, _SHARED_CACHE_MAP::BcbSpinLock, _BCB::ByteLength, CACHE_NTC_BCB, CcAcquireMasterLock, CcDecrementOpenCount, CcDirtySharedCacheMapList, CcIncrementOpenCount, CcReleaseMasterLock, CcUnpinFileData(), Context1, Context2, _BCB::Dirty, _SHARED_CACHE_MAP::DirtyPages, _SHARED_CACHE_MAP::FileObject, _BCB::FileOffset, FlagOn, _SHARED_CACHE_MAP::Flags, IS_CURSOR, _SHARED_CACHE_MAP::LogHandle, _BCB::NewestLsn, _BCB::NodeTypeCode, NTSTATUS(), NULL, _BCB::OldestLsn, _BCB::PinCount, _SHARED_CACHE_MAP::SharedCacheMapLinks, _SHARED_CACHE_MAP_LIST_CURSOR::SharedCacheMapLinks, TRUE, UNPIN, and UNREF. : This routine may be called to return all of the dirty pages in all files for a given log handle. Each page is returned by an individual call to the Dirty Page Routine. The Dirty Page Routine is defined by a prototype in ntos\inc\cache.h. Arguments: LogHandle - Log Handle which must match the log handle previously stored for all files which are to be returned. DirtyPageRoutine -- The routine to call as each dirty page for this log handle is found. Context1 - First context parameter to be passed to the Dirty Page Routine. Context2 - First context parameter to be passed to the Dirty Page Routine. Return Value: LARGE_INTEGER - Oldest Lsn found of all the dirty pages, or 0 if no dirty pages --*/ { PSHARED_CACHE_MAP SharedCacheMap; PBCB Bcb, BcbToUnpin = NULL; KIRQL OldIrql; NTSTATUS ExceptionStatus; LARGE_INTEGER SavedFileOffset, SavedOldestLsn, SavedNewestLsn; ULONG SavedByteLength; LARGE_INTEGER OldestLsn = {0,0}; // // Synchronize with changes to the SharedCacheMap list. // CcAcquireMasterLock( &OldIrql ); SharedCacheMap = CONTAINING_RECORD( CcDirtySharedCacheMapList.SharedCacheMapLinks.Flink, SHARED_CACHE_MAP, SharedCacheMapLinks ); // // Use try/finally for cleanup. The only spot where we can raise is out of the // filesystem callback, but we have the exception handler out here so we aren't // constantly setting/unsetting it. // try { while (&SharedCacheMap->SharedCacheMapLinks != &CcDirtySharedCacheMapList.SharedCacheMapLinks) { // // Skip over cursors, SharedCacheMaps for other LogHandles, and ones with // no dirty pages // if (!FlagOn(SharedCacheMap->Flags, IS_CURSOR) && (SharedCacheMap->LogHandle == LogHandle) && (SharedCacheMap->DirtyPages != 0)) { // // This SharedCacheMap should stick around for a while in the dirty list. // CcIncrementOpenCount( SharedCacheMap, 'pdGS' ); SharedCacheMap->DirtyPages += 1; CcReleaseMasterLock( OldIrql ); // // Set our initial resume point and point to first Bcb in List. // ExAcquireFastLock( &SharedCacheMap->BcbSpinLock, &OldIrql ); Bcb = CONTAINING_RECORD( SharedCacheMap->BcbList.Flink, BCB, BcbLinks ); // // Scan to the end of the Bcb list. // while (&Bcb->BcbLinks != &SharedCacheMap->BcbList) { // // If the Bcb is dirty, then capture the inputs for the // callback routine so we can call without holding a spinlock. // if ((Bcb->NodeTypeCode == CACHE_NTC_BCB) && Bcb->Dirty) { SavedFileOffset = Bcb->FileOffset; SavedByteLength = Bcb->ByteLength; SavedOldestLsn = Bcb->OldestLsn; SavedNewestLsn = Bcb->NewestLsn; // // Increment PinCount so the Bcb sticks around // Bcb->PinCount += 1; ExReleaseFastLock( &SharedCacheMap->BcbSpinLock, OldIrql ); // // Any Bcb to unpin from a previous loop? // if (BcbToUnpin != NULL) { CcUnpinFileData( BcbToUnpin, TRUE, UNREF ); BcbToUnpin = NULL; } // // Call the file system. This callback may raise status. // (*DirtyPageRoutine)( SharedCacheMap->FileObject, &SavedFileOffset, SavedByteLength, &SavedOldestLsn, &SavedNewestLsn, Context1, Context2 ); // // Possibly update OldestLsn // if ((SavedOldestLsn.QuadPart != 0) && ((OldestLsn.QuadPart == 0) || (SavedOldestLsn.QuadPart < OldestLsn.QuadPart ))) { OldestLsn = SavedOldestLsn; } // // Now reacquire the spinlock and scan from the resume point // point to the next Bcb to return in the descending list. // ExAcquireFastLock( &SharedCacheMap->BcbSpinLock, &OldIrql ); // // Normally the Bcb can stay around a while, but if not, // we will just remember it for the next time we do not // have the spin lock. We cannot unpin it now, because // we would lose our place in the list. // if (Bcb->PinCount > 1) { Bcb->PinCount -= 1; } else { BcbToUnpin = Bcb; } } Bcb = CONTAINING_RECORD( Bcb->BcbLinks.Flink, BCB, BcbLinks ); } ExReleaseFastLock( &SharedCacheMap->BcbSpinLock, OldIrql ); // // We need to unpin any Bcb we are holding before moving on to // the next SharedCacheMap, or else CcDeleteSharedCacheMap will // also delete this Bcb. // if (BcbToUnpin != NULL) { CcUnpinFileData( BcbToUnpin, TRUE, UNREF ); BcbToUnpin = NULL; } CcAcquireMasterLock( &OldIrql ); // // Now release the SharedCacheMap, leaving it in the dirty list. // CcDecrementOpenCount( SharedCacheMap, 'pdGF' ); SharedCacheMap->DirtyPages -= 1; } // // Now loop back for the next cache map. // SharedCacheMap = CONTAINING_RECORD( SharedCacheMap->SharedCacheMapLinks.Flink, SHARED_CACHE_MAP, SharedCacheMapLinks ); } CcReleaseMasterLock( OldIrql ); } finally { // // Drop the Bcb if we are being ejected. We are guaranteed that the // only raise is from the callback, at which point we have an incremented // pincount. // if (AbnormalTermination()) { CcUnpinFileData( Bcb, TRUE, UNPIN ); } } return OldestLsn; }

NTKERNELAPI PFILE_OBJECT CcGetFileObjectFromBcb (  IN PVOID  Bcb  )

Definition at line 3709 of file fssup.c. 03722 : 03723 03724 Bcb - A pointer to the pinned Bcb. 03725 03726 Return Value: 03727 03728 Pointer to the File Object, or NULL if the file is not cached or no 03729 longer cached 03730 03731 --*/ 03732 03733 { 03734 return ((PBCB)Bcb)->SharedCacheMap->FileObject; 03735 } }

NTKERNELAPI PFILE_OBJECT CcGetFileObjectFromSectionPtrs (  IN PSECTION_OBJECT_POINTERS  SectionObjectPointer  )

Definition at line 3658 of file fssup.c. References CcAcquireMasterLock, CcReleaseMasterLock, and NULL. : SectionObjectPointer - A pointer to the Section Object Pointers structure in the nonpaged Fcb. Return Value: Pointer to the File Object, or NULL if the file is not cached or no longer cached --*/ { KIRQL OldIrql; PFILE_OBJECT FileObject = NULL; // // Serialize with Creation/Deletion of all Shared CacheMaps // CcAcquireMasterLock( &OldIrql ); if (SectionObjectPointer->SharedCacheMap != NULL) { FileObject = ((PSHARED_CACHE_MAP)SectionObjectPointer->SharedCacheMap)->FileObject; } CcReleaseMasterLock( OldIrql ); return FileObject; }

NTKERNELAPI LARGE_INTEGER CcGetFlushedValidData (  IN PSECTION_OBJECT_POINTERS  SectionObjectPointer, IN BOOLEAN  BcbListHeld )

Definition at line 4232 of file cachesub.c. References ASSERT, _BITMAP_RANGE::BasePage, _BCB::BcbLinks, _SHARED_CACHE_MAP::BcbList, _SHARED_CACHE_MAP::BcbSpinLock, CACHE_NTC_BCB, CcAcquireMasterLock, CcAcquireMasterLockAtDpcLevel, CcDecrementOpenCount, CcDirtySharedCacheMapList, CcFindBitmapRangeToClean(), CcIncrementOpenCount, CcReleaseMasterLock, CcScheduleLazyWriteScan(), _BCB::Dirty, _MBCB::DirtyPages, _SHARED_CACHE_MAP::DirtyPages, _BCB::FileOffset, _BITMAP_RANGE::FirstDirtyPage, FlagOn, _SHARED_CACHE_MAP::Flags, LazyWriter, _SHARED_CACHE_MAP::Mbcb, _BCB::NodeTypeCode, NULL, _SHARED_CACHE_MAP::OpenCount, _LAZY_WRITER::OtherWork, PAGE_SHIFT, _LAZY_WRITER::ScanActive, _SHARED_CACHE_MAP_LIST_CURSOR::SharedCacheMapLinks, _SHARED_CACHE_MAP::SharedCacheMapLinks, TRUE, _SHARED_CACHE_MAP::ValidDataGoal, and WRITE_QUEUED. Referenced by CcWriteBehind(). : This routine may be called by a file system to find out how far the Cache Manager has flushed in the stream. More accurately, this routine returns either the FileOffset of the lowest dirty page currently in the file. NOTE that even though the routine takes SectionObjectPointer, the caller must insure that the stream is cached and stays cached for the duration of this routine, much like for the copy routines, etc. Arguments: SectionObjectPointer - A pointer to the Section Object Pointers structure in the nonpaged Fcb. CcInternalCaller - must be TRUE if the caller is coming from Cc, FALSE otherwise. TRUE imples the need for self-synchronization. Return Value: The derived number for flushed ValidData, or MAXLONGLONG in the quad part if the Section is not cached. (Naturally the caller can guarantee that this case does not occur, and internal callers do.) --*/ { PSHARED_CACHE_MAP SharedCacheMap; KIRQL OldIrql; LARGE_INTEGER NewValidDataLength; // // External callers may be unsynchronized with this shared cache map // perhaps going away underneath this call. NTFS and his // pair of streams for compression-on-the-wire is a good example of // someone who may be synchronized in one stream but needs to peek at // the other. // if (!CcInternalCaller) { CcAcquireMasterLock( &OldIrql ); SharedCacheMap = SectionObjectPointer->SharedCacheMap; if (SharedCacheMap == NULL) { CcReleaseMasterLock( OldIrql ); NewValidDataLength.QuadPart = MAXLONGLONG; return NewValidDataLength; } CcIncrementOpenCount( SharedCacheMap, 'dfGS' ); CcReleaseMasterLock( OldIrql ); ExAcquireSpinLock( &SharedCacheMap->BcbSpinLock, &OldIrql ); } else { SharedCacheMap = SectionObjectPointer->SharedCacheMap; } ASSERT( SharedCacheMap != NULL ); // // If the file is entirely clean, then we wish to return // the new ValidDataLength as equal to ValidDataGoal. // NewValidDataLength = SharedCacheMap->ValidDataGoal; // // If there may be dirty pages we will look at the last Bcb in the // descending-order Bcb list, and see if it describes data beyond // ValidDataGoal. // // It is important to note that since we use DirtyPages as a faux // reference count over some short windows (+1, -1) the simple // fact it is nonzero does *not* mean the file is dirty. // // (This test is logically too conservative. For example, the last Bcb // may not even be dirty (in which case we should look at its // predecessor), or we may have earlier written valid data to this // byte range (which also means if we knew this we could look at // the predessor). This simply means that the Lazy Writer may not // successfully get ValidDataLength updated in a file being randomly // accessed until the level of file access dies down, or at the latest // until the file is closed. However, security will never be // compromised.) // if (SharedCacheMap->DirtyPages) { PBITMAP_RANGE BitmapRange; PBCB LastBcb; PMBCB Mbcb = SharedCacheMap->Mbcb; if ((Mbcb != NULL) && (Mbcb->DirtyPages != 0)) { BitmapRange = CcFindBitmapRangeToClean( Mbcb, 0 ); ASSERT(BitmapRange->FirstDirtyPage != MAXULONG); NewValidDataLength.QuadPart = (BitmapRange->BasePage + BitmapRange->FirstDirtyPage) << PAGE_SHIFT; } LastBcb = CONTAINING_RECORD( SharedCacheMap->BcbList.Flink, BCB, BcbLinks ); while (&LastBcb->BcbLinks != &SharedCacheMap->BcbList) { if ((LastBcb->NodeTypeCode == CACHE_NTC_BCB) && LastBcb->Dirty) { break; } LastBcb = CONTAINING_RECORD( LastBcb->BcbLinks.Flink, BCB, BcbLinks ); } // // Check the Base of the last entry. // if ((&LastBcb->BcbLinks != &SharedCacheMap->BcbList) && (LastBcb->FileOffset.QuadPart < NewValidDataLength.QuadPart )) { NewValidDataLength = LastBcb->FileOffset; } } if (!CcInternalCaller) { // // Remove our reference. // CcAcquireMasterLockAtDpcLevel(); CcDecrementOpenCount( SharedCacheMap, 'dfGF' ); if ((SharedCacheMap->OpenCount == 0) && !FlagOn(SharedCacheMap->Flags, WRITE_QUEUED) && (SharedCacheMap->DirtyPages == 0)) { // // Move to the dirty list. // RemoveEntryList( &SharedCacheMap->SharedCacheMapLinks ); InsertTailList( &CcDirtySharedCacheMapList.SharedCacheMapLinks, &SharedCacheMap->SharedCacheMapLinks ); // // Make sure the Lazy Writer will wake up, because we // want him to delete this SharedCacheMap. // LazyWriter.OtherWork = TRUE; if (!LazyWriter.ScanActive) { CcScheduleLazyWriteScan(); } } ExReleaseSpinLockFromDpcLevel( &SharedCacheMap->BcbSpinLock ); CcReleaseMasterLock( OldIrql ); } return NewValidDataLength; }

NTKERNELAPI LARGE_INTEGER CcGetLsnForFileObject (  IN PFILE_OBJECT  FileObject, OUT PLARGE_INTEGER OldestLsn  OPTIONAL )

Definition at line 450 of file logsup.c. References _BCB::BcbLinks, _SHARED_CACHE_MAP::BcbList, _SHARED_CACHE_MAP::BcbSpinLock, CACHE_NTC_BCB, _BCB::Dirty, _BCB::NewestLsn, _BCB::NodeTypeCode, NULL, and _BCB::OldestLsn. 00457 : 00458 00459 This routine returns the oldest and newest LSNs for a file object. 00460 00461 Arguments: 00462 00463 FileObject - File for which the log handle should be stored. 00464 00465 OldestLsn - pointer to location to store oldest LSN for file object. 00466 00467 Return Value: 00468 00469 The newest LSN for the file object. 00470 00471 --*/ 00472 00473 { 00474 PBCB Bcb; 00475 KIRQL OldIrql; 00476 LARGE_INTEGER Oldest, Newest; 00477 PSHARED_CACHE_MAP SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; 00478 00479 // 00480 // initialize lsn variables 00481 // 00482 00483 Oldest.LowPart = 0; 00484 Oldest.HighPart = 0; 00485 Newest.LowPart = 0; 00486 Newest.HighPart = 0; 00487 00488 if(SharedCacheMap == NULL) { 00489 return Oldest; 00490 } 00491 00492 ExAcquireFastLock(&SharedCacheMap->BcbSpinLock, &OldIrql); 00493 00494 // 00495 // Now point to first Bcb in List, and loop through it. 00496 // 00497 00498 Bcb = CONTAINING_RECORD( SharedCacheMap->BcbList.Flink, BCB, BcbLinks ); 00499 00500 while (&Bcb->BcbLinks != &SharedCacheMap->BcbList) { 00501 00502 // 00503 // If the Bcb is dirty then capture the oldest and newest lsn 00504 // 00505 00506 00507 if ((Bcb->NodeTypeCode == CACHE_NTC_BCB) && Bcb->Dirty) { 00508 00509 LARGE_INTEGER BcbLsn, BcbNewest; 00510 00511 BcbLsn = Bcb->OldestLsn; 00512 BcbNewest = Bcb->NewestLsn; 00513 00514 if ((BcbLsn.QuadPart != 0) && 00515 ((Oldest.QuadPart == 0) || 00516 (BcbLsn.QuadPart < Oldest.QuadPart))) { 00517 00518 Oldest = BcbLsn; 00519 } 00520 00521 if ((BcbLsn.QuadPart != 0) && (BcbNewest.QuadPart > Newest.QuadPart)) { 00522 00523 Newest = BcbNewest; 00524 } 00525 } 00526 00527 00528 Bcb = CONTAINING_RECORD( Bcb->BcbLinks.Flink, BCB, BcbLinks ); 00529 } 00530 00531 // 00532 // Now release the spin lock for this Bcb list and generate a callback 00533 // if we got something. 00534 // 00535 00536 ExReleaseFastLock( &SharedCacheMap->BcbSpinLock, OldIrql ); 00537 00538 if (ARGUMENT_PRESENT(OldestLsn)) { 00539 00540 *OldestLsn = Oldest; 00541 } 00542 00543 return Newest; 00544 } }

NTKERNELAPI BOOLEAN CcInitializeCacheManager (   )

Definition at line 69 of file fssup.c. References _LAZY_WRITER::BcbZone, CcAggressiveZeroCount, CcAggressiveZeroThreshold, CcBcbSpinLock, CcBugCheck, CcCapturedSystemSize, CcCleanSharedCacheMapList, CcDebugTraceLock, CcDeferredWrites, CcDeferredWriteSpinLock, CcDirtyPageTarget, CcDirtyPageThreshold, CcDirtySharedCacheMapList, CcExpressWorkQueue, CcIdleDelayTick, CcIdleWorkerThreadList, CcInitializeVacbs(), CcLazyWriterCursor, CcMasterSpinLock, CcNumberWorkerThreads, CcPostTickWorkQueue, CcRegularWorkQueue, CcScanDpc(), CcTwilightLookasideList, CcWorkerThread(), CcWorkQueueSpinlock, ExAllocatePoolWithTag, ExCriticalWorkerThreads, ExInitializeNPagedLookasideList(), ExInitializeWorkItem, ExInitializeZone(), _SHARED_CACHE_MAP_LIST_CURSOR::Flags, Index, IS_CURSOR, KeInitializeDpc(), KeInitializeSpinLock(), KeInitializeTimer(), KeNumberProcessors, KeQueryTimeIncrement(), KiProcessorBlock, LAZY_WRITER_IDLE_DELAY, LazyWriter, _WORK_QUEUE_ITEM::List, LookasideTwilightList, _MMSUPPORT::MaximumWorkingSetSize, MmIsThisAnNtAsSystem(), MmLargeSystem, MmLargeSystemCache, MmMediumSystem, MmNumberOfPhysicalPages, MmQuerySystemSize(), MmSmallSystem, MmSystemCacheWs, NonPagedPool, NT_SUCCESS, NULL, _LAZY_WRITER::OurProcess, PAGE_SIZE, PsGetCurrentProcess, _LAZY_WRITER::ScanDpc, _LAZY_WRITER::ScanTimer, _SHARED_CACHE_MAP_LIST_CURSOR::SharedCacheMapLinks, TRUE, USHORT, WORK_QUEUE_ENTRY, and _LAZY_WRITER::WorkQueue. : This routine must be called during system initialization before the first call to any file system, to allow the Cache Manager to initialize its global data structures. This routine has no dependencies on other system components being initialized. Arguments: None Return Value: TRUE if initialization was successful --*/ { CLONG i; ULONG Index; PNPAGED_LOOKASIDE_LIST Lookaside; USHORT NumberOfItems; PKPRCB Prcb; PWORK_QUEUE_ITEM WorkItem; #ifdef CCDBG_LOCK KeInitializeSpinLock( &CcDebugTraceLock ); #endif #if DBG CcBcbCount = 0; InitializeListHead( &CcBcbList ); KeInitializeSpinLock( &CcBcbSpinLock ); #endif // // Figure out the timeout clock tick for the lazy writer. // CcIdleDelayTick = LAZY_WRITER_IDLE_DELAY / KeQueryTimeIncrement(); // // Initialize shared cache map list structures // KeInitializeSpinLock( &CcMasterSpinLock ); InitializeListHead( &CcCleanSharedCacheMapList ); InitializeListHead( &CcDirtySharedCacheMapList.SharedCacheMapLinks ); CcDirtySharedCacheMapList.Flags = IS_CURSOR; InsertTailList( &CcDirtySharedCacheMapList.SharedCacheMapLinks, &CcLazyWriterCursor.SharedCacheMapLinks ); CcLazyWriterCursor.Flags = IS_CURSOR; // // Initialize worker thread structures // KeInitializeSpinLock( &CcWorkQueueSpinlock ); InitializeListHead( &CcIdleWorkerThreadList ); InitializeListHead( &CcExpressWorkQueue ); InitializeListHead( &CcRegularWorkQueue ); InitializeListHead( &CcPostTickWorkQueue ); // // Set the number of worker threads based on the system size. // CcCapturedSystemSize = MmQuerySystemSize(); if (CcNumberWorkerThreads == 0) { switch (CcCapturedSystemSize) { case MmSmallSystem: CcNumberWorkerThreads = ExCriticalWorkerThreads - 1; CcDirtyPageThreshold = MmNumberOfPhysicalPages / 8; CcAggressiveZeroThreshold = 1; break; case MmMediumSystem: CcNumberWorkerThreads = ExCriticalWorkerThreads - 1; CcDirtyPageThreshold = MmNumberOfPhysicalPages / 4; CcAggressiveZeroThreshold = 2; break; case MmLargeSystem: CcNumberWorkerThreads = ExCriticalWorkerThreads - 2; CcDirtyPageThreshold = MmNumberOfPhysicalPages / 4 + MmNumberOfPhysicalPages / 8; CcAggressiveZeroThreshold = 4; #if 0 // // Use more memory if we are a large server. // if ((MmLargeSystemCache != 0) && (CcDirtyPageThreshold < (MmNumberOfPhysicalPages - (0xE00000 / PAGE_SIZE)))) { CcDirtyPageThreshold = MmNumberOfPhysicalPages - (0xE00000 / PAGE_SIZE); } #endif break; default: CcNumberWorkerThreads = 1; CcDirtyPageThreshold = MmNumberOfPhysicalPages / 8; } // CcDirtyPageThreshold = (2*1024*1024)/PAGE_SIZE; if (MmSystemCacheWs.MaximumWorkingSetSize > ((4*1024*1024)/PAGE_SIZE)) { CcDirtyPageThreshold = MmSystemCacheWs.MaximumWorkingSetSize - ((2*1024*1024)/PAGE_SIZE); } CcDirtyPageTarget = CcDirtyPageThreshold / 2 + CcDirtyPageThreshold / 4; } CcAggressiveZeroCount = 0; // // Now allocate and initialize the above number of worker thread // items. // for (i = 0; i < CcNumberWorkerThreads; i++) { WorkItem = ExAllocatePoolWithTag( NonPagedPool, sizeof(WORK_QUEUE_ITEM), 'qWcC' ); if (WorkItem == NULL) { CcBugCheck( 0, 0, 0 ); } // // Initialize the work queue item and insert in our queue // of potential worker threads. // ExInitializeWorkItem( WorkItem, CcWorkerThread, WorkItem ); InsertTailList( &CcIdleWorkerThreadList, &WorkItem->List ); } // // Initialize the Lazy Writer thread structure, and start him up. // RtlZeroMemory( &LazyWriter, sizeof(LAZY_WRITER) ); KeInitializeSpinLock( &CcWorkQueueSpinlock ); InitializeListHead( &LazyWriter.WorkQueue ); // // Store process address // LazyWriter.OurProcess = PsGetCurrentProcess(); // // Initialize the Scan Dpc and Timer. // KeInitializeDpc( &LazyWriter.ScanDpc, &CcScanDpc, NULL ); KeInitializeTimer( &LazyWriter.ScanTimer ); // // Now initialize the lookaside list for allocating Work Queue entries. // switch ( CcCapturedSystemSize ) { // // ~512 bytes // case MmSmallSystem : NumberOfItems = 32; break; // // ~1k bytes // case MmMediumSystem : NumberOfItems = 64; break; // // ~2k bytes // case MmLargeSystem : NumberOfItems = 128; if (MmIsThisAnNtAsSystem()) { NumberOfItems += 128; } break; } ExInitializeNPagedLookasideList( &CcTwilightLookasideList, NULL, NULL, 0, sizeof( WORK_QUEUE_ENTRY ), 'kWcC', NumberOfItems ); // // Initialize the per processor nonpaged lookaside lists and descriptors. // for (Index = 0; Index < (ULONG)KeNumberProcessors; Index += 1) { Prcb = KiProcessorBlock[Index]; // // Initialize the large IRP per processor lookaside pointers. // Prcb->PPLookasideList[LookasideTwilightList].L = &CcTwilightLookasideList; Lookaside = (PNPAGED_LOOKASIDE_LIST)ExAllocatePoolWithTag( NonPagedPool, sizeof(NPAGED_LOOKASIDE_LIST), 'KWcC'); if (Lookaside != NULL) { ExInitializeNPagedLookasideList( Lookaside, NULL, NULL, 0, sizeof( WORK_QUEUE_ENTRY ), 'KWcC', NumberOfItems ); } else { Lookaside = &CcTwilightLookasideList; } Prcb->PPLookasideList[LookasideTwilightList].P = Lookaside; } // // Now initialize the Bcb zone // { PVOID InitialSegment; ULONG InitialSegmentSize; ULONG RoundedBcbSize = (sizeof(BCB) + 7) & ~7; switch ( CcCapturedSystemSize ) { // // ~1.5k bytes // case MmSmallSystem : InitialSegmentSize = sizeof(ZONE_SEGMENT_HEADER) + RoundedBcbSize * 8; break; // // 1 Page // case MmMediumSystem : InitialSegmentSize = PAGE_SIZE; break; // // 3 Pages // case MmLargeSystem : InitialSegmentSize = 3 * PAGE_SIZE; break; } // // Allocate the initial allocation for the zone. If we cannot get it, // something must really be wrong, so we will just bugcheck. // if ((InitialSegment = ExAllocatePoolWithTag( NonPagedPool, InitialSegmentSize, 'zBcC' )) == NULL) { CcBugCheck( 0, 0, 0 ); } if (!NT_SUCCESS(ExInitializeZone( &LazyWriter.BcbZone, RoundedBcbSize, InitialSegment, InitialSegmentSize ))) { CcBugCheck( 0, 0, 0 ); } } // // Initialize the Deferred Write List. // KeInitializeSpinLock( &CcDeferredWriteSpinLock ); InitializeListHead( &CcDeferredWrites ); // // Initialize the Vacbs. // CcInitializeVacbs(); return TRUE; }

NTKERNELAPI VOID CcInitializeCacheMap (  IN PFILE_OBJECT  FileObject, IN PCC_FILE_SIZES  FileSizes, IN BOOLEAN  PinAccess, IN PCACHE_MANAGER_CALLBACKS  Callbacks, IN PVOID  LazyWriteContext )

Definition at line 387 of file fssup.c. References _SHARED_CACHE_MAP::ActiveVacbSpinLock, _CC_FILE_SIZES::AllocationSize, ASSERT, _SHARED_CACHE_MAP::BcbList, _SHARED_CACHE_MAP::BcbSpinLock, BEING_CREATED, CACHE_NTC_PRIVATE_CACHE_MAP, CACHE_NTC_SHARED_CACHE_MAP, _SHARED_CACHE_MAP::Callbacks, CcAcquireMasterLock, CcCleanSharedCacheMapList, CcCreateVacbArray(), CcDecrementOpenCount, CcDeleteSharedCacheMap(), CcDirtySharedCacheMapList, CcExtendVacbArray(), CcIncrementOpenCount, CcReleaseMasterLock, CcScheduleLazyWriteScan(), ClearFlag, _SHARED_CACHE_MAP::CreateEvent, DebugTrace, DebugTrace2, DEFAULT_CREATE_MODULO, _SHARED_CACHE_MAP::DirtyPages, _CACHE_UNINITIALIZE_EVENT::Event, _SHARED_CACHE_MAP::Event, ExAllocatePoolWithTag, Executive, ExFreePool(), ExRaiseStatus(), FALSE, _PRIVATE_CACHE_MAP::FileObject, _SHARED_CACHE_MAP::FileObject, _CC_FILE_SIZES::FileSize, _SHARED_CACHE_MAP::FileSize, FlagOn, _SHARED_CACHE_MAP::Flags, FO_RANDOM_ACCESS, FO_SEQUENTIAL_ONLY, FSRTL_FLAG2_DO_MODIFIED_WRITE, FsRtlNormalizeNtstatus(), KeInitializeEvent, KeInitializeSpinLock(), KernelMode, KeSetEvent(), KeWaitForSingleObject(), _SHARED_CACHE_MAP::LazyWriteContext, LazyWriter, _SHARED_CACHE_MAP::LocalEvent, me, mm, MmCreateSection(), MmDisableModifiedWriteOfSection(), MmExtendSection(), MODIFIED_WRITE_DISABLED, _CACHE_UNINITIALIZE_EVENT::Next, _PRIVATE_CACHE_MAP::NodeByteSize, _SHARED_CACHE_MAP::NodeByteSize, _PRIVATE_CACHE_MAP::NodeTypeCode, _SHARED_CACHE_MAP::NodeTypeCode, NonPagedPool, NT_SUCCESS, NTSTATUS(), NULL, ObDeleteCapturedInsertInfo(), ObReferenceObject, ONLY_SEQUENTIAL_ONLY_SEEN, _SHARED_CACHE_MAP::OpenCount, _LAZY_WRITER::OtherWork, PAGE_SIZE, PIN_ACCESS, PRIVATE_CACHE_MAP, _SHARED_CACHE_MAP::PrivateCacheMap, _PRIVATE_CACHE_MAP::PrivateLinks, _SHARED_CACHE_MAP::PrivateList, RANDOM_ACCESS_SEEN, _PRIVATE_CACHE_MAP::ReadAheadMask, _PRIVATE_CACHE_MAP::ReadAheadSpinLock, _LAZY_WRITER::ScanActive, _SHARED_CACHE_MAP::Section, _SHARED_CACHE_MAP::SectionSize, SetFlag, SHARED_CACHE_MAP, _SHARED_CACHE_MAP_LIST_CURSOR::SharedCacheMapLinks, _SHARED_CACHE_MAP::SharedCacheMapLinks, Status, _SHARED_CACHE_MAP::Status, TRUE, TRUNCATE_REQUIRED, try_return, _SHARED_CACHE_MAP::UninitializeEvent, VACB_MAPPING_GRANULARITY, _SHARED_CACHE_MAP::Vacbs, _SHARED_CACHE_MAP::ValidDataGoal, _CC_FILE_SIZES::ValidDataLength, _SHARED_CACHE_MAP::ValidDataLength, and WRITE_QUEUED. Referenced by UdfCommonRead(), and UdfCreateInternalStream(). : This routine is intended to be called by File Systems only. It initializes the cache maps for data caching. It should be called every time a file is open or created, and NO_INTERMEDIATE_BUFFERING was specified as FALSE. Arguments: FileObject - A pointer to the newly-created file object. FileSizes - A pointer to AllocationSize, FileSize and ValidDataLength for the file. ValidDataLength should contain MAXLONGLONG if valid data length tracking and callbacks are not desired. PinAccess - FALSE if file will be used exclusively for Copy and Mdl access, or TRUE if file will be used for Pin access. (Files for Pin access are not limited in size as the caller must access multiple areas of the file at once.) Callbacks - Structure of callbacks used by the Lazy Writer LazyWriteContext - Parameter to be passed in to above routine. Return Value: None. If an error occurs, this routine will Raise the status. --*/ { KIRQL OldIrql; PSHARED_CACHE_MAP SharedCacheMap = NULL; PVOID CacheMapToFree = NULL; CC_FILE_SIZES LocalSizes; BOOLEAN WeSetBeingCreated = FALSE; BOOLEAN SharedListOwned = FALSE; BOOLEAN MustUninitialize = FALSE; BOOLEAN WeCreated = FALSE; DebugTrace(+1, me, "CcInitializeCacheMap:\n", 0 ); DebugTrace( 0, me, " FileObject = %08lx\n", FileObject ); DebugTrace( 0, me, " FileSizes = %08lx\n", FileSizes ); // // Make a local copy of the passed in file sizes before acquiring // the spin lock. // LocalSizes = *FileSizes; // // If no FileSize was given, set to one byte before maximizing below. // if (LocalSizes.AllocationSize.QuadPart == 0) { LocalSizes.AllocationSize.LowPart += 1; } // // If caller has Write access or will allow write, then round // size to next create modulo. (***Temp*** there may be too many // apps that end up allowing shared write, thanks to our Dos heritage, // to keep that part of the check in.) // if (FileObject->WriteAccess /*|| FileObject->SharedWrite */) { LocalSizes.AllocationSize.QuadPart = LocalSizes.AllocationSize.QuadPart + (LONGLONG)(DEFAULT_CREATE_MODULO - 1); LocalSizes.AllocationSize.LowPart &= ~(DEFAULT_CREATE_MODULO - 1); } else { LocalSizes.AllocationSize.QuadPart = LocalSizes.AllocationSize.QuadPart + (LONGLONG)(VACB_MAPPING_GRANULARITY - 1); LocalSizes.AllocationSize.LowPart &= ~(VACB_MAPPING_GRANULARITY - 1); } // // Do the allocate of the SharedCacheMap, based on an unsafe test, // while not holding a spinlock. Allocation failures look like we // never decided to allocate one here! // if (FileObject->SectionObjectPointer->SharedCacheMap == NULL) { CacheMapToFree = ExAllocatePoolWithTag( NonPagedPool, sizeof(SHARED_CACHE_MAP), 'cScC' ); } // // Serialize Creation/Deletion of all Shared CacheMaps // CcAcquireMasterLock( &OldIrql ); SharedListOwned = TRUE; // // Insure release of our global resource // try { // // Check for second initialization of same file object // if (FileObject->PrivateCacheMap != NULL) { DebugTrace( 0, 0, "CacheMap already initialized\n", 0 ); try_return( NOTHING ); } // // Get current Shared Cache Map pointer indirectly off of the file object. // (The actual pointer is typically in a file system data structure, such // as an Fcb.) // SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; // // If there is no SharedCacheMap, then we must create a section and // the SharedCacheMap structure. // if (SharedCacheMap == NULL) { // // After successfully creating the section, allocate the SharedCacheMap. // WeCreated = TRUE; if (CacheMapToFree == NULL) { CacheMapToFree = (PSHARED_CACHE_MAP)ExAllocatePoolWithTag( NonPagedPool, sizeof(SHARED_CACHE_MAP), 'cScC' ); } SharedCacheMap = CacheMapToFree; CacheMapToFree = NULL; if (SharedCacheMap == NULL) { DebugTrace( 0, 0, "Failed to allocate SharedCacheMap\n", 0 ); CcReleaseMasterLock( OldIrql ); SharedListOwned = FALSE; ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } // // Zero the SharedCacheMap and fill in the nonzero portions later. // RtlZeroMemory( SharedCacheMap, sizeof(SHARED_CACHE_MAP) ); #if DANLO SharedCacheMap->OpenCountLog.Size = sizeof(SharedCacheMap->OpenCountLog.Log)/sizeof(CC_LOG_ENTRY); #endif // // Now initialize the Shared Cache Map. // SharedCacheMap->NodeTypeCode = CACHE_NTC_SHARED_CACHE_MAP; SharedCacheMap->NodeByteSize = sizeof(SHARED_CACHE_MAP); SharedCacheMap->FileObject = FileObject; SharedCacheMap->FileSize = LocalSizes.FileSize; SharedCacheMap->ValidDataLength = LocalSizes.ValidDataLength; SharedCacheMap->ValidDataGoal = LocalSizes.ValidDataLength; // SharedCacheMap->Section set below // // Initialize the spin locks. // KeInitializeSpinLock( &SharedCacheMap->ActiveVacbSpinLock ); KeInitializeSpinLock( &SharedCacheMap->BcbSpinLock ); if (PinAccess) { SetFlag(SharedCacheMap->Flags, PIN_ACCESS); } // // Initialize our allocation hint for the local event. // SharedCacheMap->LocalEvent = &SharedCacheMap->Event; // // If this file has FO_SEQUENTIAL_ONLY set, then remember that // in the SharedCacheMap. // if (FlagOn(FileObject->Flags, FO_SEQUENTIAL_ONLY)) { SetFlag(SharedCacheMap->Flags, ONLY_SEQUENTIAL_ONLY_SEEN); } // // Do the round-robin allocation of the spinlock for the shared // cache map. Note the manipulation of the next // counter is safe, since we have the CcMasterSpinLock // exclusive. // InitializeListHead( &SharedCacheMap->BcbList ); SharedCacheMap->Callbacks = Callbacks; SharedCacheMap->LazyWriteContext = LazyWriteContext; // // Initialize listhead for all PrivateCacheMaps // InitializeListHead( &SharedCacheMap->PrivateList ); // // Insert the new Shared Cache Map in the global list // InsertTailList( &CcCleanSharedCacheMapList, &SharedCacheMap->SharedCacheMapLinks ); // // Finally, store the pointer to the Shared Cache Map back // via the indirect pointer in the File Object. // FileObject->SectionObjectPointer->SharedCacheMap = SharedCacheMap; // // We must reference this file object so that it cannot go away // until we do CcUninitializeCacheMap below. Note we cannot // find or rely on the FileObject that Memory Management has, // although normally it will be this same one anyway. // ObReferenceObject ( FileObject ); } else { // // If this file has FO_SEQUENTIAL_ONLY clear, then remember that // in the SharedCacheMap. // if (!FlagOn(FileObject->Flags, FO_SEQUENTIAL_ONLY)) { ClearFlag(SharedCacheMap->Flags, ONLY_SEQUENTIAL_ONLY_SEEN); } } // // If this file is opened for random access, remember this in // the SharedCacheMap. // if (FlagOn(FileObject->Flags, FO_RANDOM_ACCESS)) { SetFlag(SharedCacheMap->Flags, RANDOM_ACCESS_SEEN); } // // Make sure that no one is trying to lazy delete it in the case // that the Cache Map was already there. // ClearFlag(SharedCacheMap->Flags, TRUNCATE_REQUIRED); // // In case there has been a CcUnmapAndPurge call, we check here if we // if we need to recreate the section and map it. // if ((SharedCacheMap->Vacbs == NULL) && !FlagOn(SharedCacheMap->Flags, BEING_CREATED)) { // // Increment the OpenCount on the CacheMap. // CcIncrementOpenCount( SharedCacheMap, 'onnI' ); MustUninitialize = TRUE; // // We still want anyone else to wait. // SetFlag(SharedCacheMap->Flags, BEING_CREATED); WeSetBeingCreated = TRUE; // // If there is a create event, then this must be the path where we // we were only unmapped. We will just clear it here again in case // someone needs to wait again this time too. // if (SharedCacheMap->CreateEvent != NULL) { KeInitializeEvent( SharedCacheMap->CreateEvent, NotificationEvent, FALSE ); } // // Release global resource // CcReleaseMasterLock( OldIrql ); SharedListOwned = FALSE; // // We have to test this, because the section may only be unmapped. // if (SharedCacheMap->Section == NULL) { LARGE_INTEGER LargeZero = {0,0}; // // Call MM to create a section for this file, for the calculated // section size. Note that we have the choice in this service to // pass in a FileHandle or a FileObject pointer, but not both. // Naturally we want to pass in the handle. // DebugTrace( 0, mm, "MmCreateSection:\n", 0 ); DebugTrace2(0, mm, " MaximumSize = %08lx, %08lx\n", LocalSizes.AllocationSize.LowPart, LocalSizes.AllocationSize.HighPart ); DebugTrace( 0, mm, " FileObject = %08lx\n", FileObject ); SharedCacheMap->Status = MmCreateSection( &SharedCacheMap->Section, SECTION_MAP_READ | SECTION_MAP_WRITE | SECTION_QUERY, NULL, &LocalSizes.AllocationSize, PAGE_READWRITE, SEC_COMMIT, NULL, FileObject ); DebugTrace( 0, mm, " <Section = %08lx\n", SharedCacheMap->Section ); if (!NT_SUCCESS( SharedCacheMap->Status )){ DebugTrace( 0, 0, "Error from MmCreateSection = %08lx\n", SharedCacheMap->Status ); SharedCacheMap->Section = NULL; ExRaiseStatus( FsRtlNormalizeNtstatus( SharedCacheMap->Status, STATUS_UNEXPECTED_MM_CREATE_ERR )); } ObDeleteCapturedInsertInfo(SharedCacheMap->Section); // // If this is a stream file object, then no user can map it, // and we should keep the modified page writer out of it. // if (!FlagOn(((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->Flags2, FSRTL_FLAG2_DO_MODIFIED_WRITE) && (FileObject->FsContext2 == NULL)) { BOOLEAN Disabled; Disabled = MmDisableModifiedWriteOfSection( FileObject->SectionObjectPointer ); CcAcquireMasterLock( &OldIrql ); SetFlag(SharedCacheMap->Flags, MODIFIED_WRITE_DISABLED); CcReleaseMasterLock( OldIrql ); //**** ASSERT( Disabled ); } // // Create the Vacb array. // CcCreateVacbArray( SharedCacheMap, LocalSizes.AllocationSize ); } // // If the section already exists, we still have to call MM to // extend, in case it is not large enough. // else { if ( LocalSizes.AllocationSize.QuadPart > SharedCacheMap->SectionSize.QuadPart ) { NTSTATUS Status; DebugTrace( 0, mm, "MmExtendSection:\n", 0 ); DebugTrace( 0, mm, " Section = %08lx\n", SharedCacheMap->Section ); DebugTrace2(0, mm, " Size = %08lx, %08lx\n", LocalSizes.AllocationSize.LowPart, LocalSizes.AllocationSize.HighPart ); Status = MmExtendSection( SharedCacheMap->Section, &LocalSizes.AllocationSize, TRUE ); if (!NT_SUCCESS(Status)) { DebugTrace( 0, 0, "Error from MmExtendSection, Status = %08lx\n", Status ); ExRaiseStatus( FsRtlNormalizeNtstatus( Status, STATUS_UNEXPECTED_MM_EXTEND_ERR )); } } // // Extend the Vacb array. // CcExtendVacbArray( SharedCacheMap, LocalSizes.AllocationSize ); } // // Now show that we are all done and resume any waiters. // CcAcquireMasterLock( &OldIrql ); ClearFlag(SharedCacheMap->Flags, BEING_CREATED); WeSetBeingCreated = FALSE; if (SharedCacheMap->CreateEvent != NULL) { KeSetEvent( SharedCacheMap->CreateEvent, 0, FALSE ); } CcReleaseMasterLock( OldIrql ); } // // Else if the section is already there, we make sure it is large // enough by calling CcExtendCacheSection. // else { // // If the SharedCacheMap is currently being created we have // to optionally create and wait on an event for it. Note that // the only safe time to delete the event is in // CcUninitializeCacheMap, because we otherwise have no way of // knowing when everyone has reached the KeWaitForSingleObject. // if (FlagOn(SharedCacheMap->Flags, BEING_CREATED)) { if (SharedCacheMap->CreateEvent == NULL) { // // If the local event is not being used then we can grab it. // (Should be quite rare that it is in use.) // SharedCacheMap->CreateEvent = InterlockedExchangePointer( &SharedCacheMap->LocalEvent, NULL ); if (SharedCacheMap->CreateEvent == NULL) { SharedCacheMap->CreateEvent = (PKEVENT)ExAllocatePoolWithTag( NonPagedPool, sizeof(KEVENT), 'vEcC' ); } if (SharedCacheMap->CreateEvent == NULL) { DebugTrace( 0, 0, "Failed to allocate CreateEvent\n", 0 ); CcReleaseMasterLock( OldIrql ); SharedListOwned = FALSE; ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES); } KeInitializeEvent( SharedCacheMap->CreateEvent, NotificationEvent, FALSE ); } // // Increment the OpenCount on the CacheMap. // CcIncrementOpenCount( SharedCacheMap, 'ecnI' ); MustUninitialize = TRUE; // // Release global resource before waiting // CcReleaseMasterLock( OldIrql ); SharedListOwned = FALSE; DebugTrace( 0, 0, "Waiting on CreateEvent\n", 0 ); KeWaitForSingleObject( SharedCacheMap->CreateEvent, Executive, KernelMode, FALSE, (PLARGE_INTEGER)NULL); // // If the real creator got an error, then we must bomb // out too. // if (!NT_SUCCESS(SharedCacheMap->Status)) { ExRaiseStatus( FsRtlNormalizeNtstatus( SharedCacheMap->Status, STATUS_UNEXPECTED_MM_CREATE_ERR )); } } else { PCACHE_UNINITIALIZE_EVENT CUEvent, EventNext; // // Increment the OpenCount on the CacheMap. // CcIncrementOpenCount( SharedCacheMap, 'esnI' ); MustUninitialize = TRUE; // // If there is a process waiting on an uninitialize on this // cache map to complete, let the thread that is waiting go, // since the uninitialize is now complete. // CUEvent = SharedCacheMap->UninitializeEvent; while (CUEvent != NULL) { EventNext = CUEvent->Next; KeSetEvent(&CUEvent->Event, 0, FALSE); CUEvent = EventNext; } SharedCacheMap->UninitializeEvent = NULL; // // Release global resource // CcReleaseMasterLock( OldIrql ); SharedListOwned = FALSE; } } { PPRIVATE_CACHE_MAP PrivateCacheMap; // // Now allocate (if local one already in use) and initialize // the Private Cache Map. // PrivateCacheMap = &SharedCacheMap->PrivateCacheMap; // // See if we should allocate a PrivateCacheMap while not holding // a spinlock. // if (CacheMapToFree != NULL) { ExFreePool( CacheMapToFree ); CacheMapToFree = NULL; } if (PrivateCacheMap->NodeTypeCode != 0) { CacheMapToFree = ExAllocatePoolWithTag( NonPagedPool, sizeof(PRIVATE_CACHE_MAP), 'cPcC' ); } // // Insert the new PrivateCacheMap in the list off the SharedCacheMap. // CcAcquireMasterLock( &OldIrql ); SharedListOwned = TRUE; // // Now make sure there is still no PrivateCacheMap, and if so just get out. // if (FileObject->PrivateCacheMap == NULL) { // // Is the local one already in use? // if (PrivateCacheMap->NodeTypeCode != 0) { // // Use the one allocated above, if there is one, else go to pool now. // if (CacheMapToFree == NULL) { CacheMapToFree = (PPRIVATE_CACHE_MAP)ExAllocatePoolWithTag( NonPagedPool, sizeof(PRIVATE_CACHE_MAP), 'cPcC' ); } PrivateCacheMap = CacheMapToFree; CacheMapToFree = NULL; } if (PrivateCacheMap == NULL) { DebugTrace( 0, 0, "Failed to allocate PrivateCacheMap\n", 0 ); CcReleaseMasterLock( OldIrql ); SharedListOwned = FALSE; ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES); } RtlZeroMemory( PrivateCacheMap, sizeof(PRIVATE_CACHE_MAP) ); PrivateCacheMap->NodeTypeCode = CACHE_NTC_PRIVATE_CACHE_MAP; PrivateCacheMap->NodeByteSize = sizeof(PRIVATE_CACHE_MAP); PrivateCacheMap->FileObject = FileObject; PrivateCacheMap->ReadAheadMask = PAGE_SIZE - 1; // // Initialize the spin lock. // KeInitializeSpinLock( &PrivateCacheMap->ReadAheadSpinLock ); InsertTailList( &SharedCacheMap->PrivateList, &PrivateCacheMap->PrivateLinks ); FileObject->PrivateCacheMap = PrivateCacheMap; } else { // // We raced with another initializer for the same fileobject and must // drop our (to this point speculative) opencount. // ASSERT( SharedCacheMap->OpenCount > 1 ); CcDecrementOpenCount( SharedCacheMap, 'rpnI' ); SharedCacheMap = NULL; } } MustUninitialize = FALSE; try_exit: NOTHING; } finally { // // See if we got an error and must uninitialize the SharedCacheMap // if (MustUninitialize) { if (!SharedListOwned) { CcAcquireMasterLock( &OldIrql ); } if (WeSetBeingCreated) { if (SharedCacheMap->CreateEvent != NULL) { KeSetEvent( SharedCacheMap->CreateEvent, 0, FALSE ); } ClearFlag(SharedCacheMap->Flags, BEING_CREATED); } // // Now release our open count. // CcDecrementOpenCount( SharedCacheMap, 'umnI' ); if ((SharedCacheMap->OpenCount == 0) && !FlagOn(SharedCacheMap->Flags, WRITE_QUEUED) && (SharedCacheMap->DirtyPages == 0)) { // // On PinAccess it is safe and necessary to eliminate // the structure immediately. // if (PinAccess) { CcDeleteSharedCacheMap( SharedCacheMap, OldIrql, FALSE ); // // If it is not PinAccess, we must lazy delete, because // we could get into a deadlock trying to acquire the // stream exclusive when we dereference the file object. // } else { // // Move it to the dirty list so the lazy write scan will // see it. // RemoveEntryList( &SharedCacheMap->SharedCacheMapLinks ); InsertTailList( &CcDirtySharedCacheMapList.SharedCacheMapLinks, &SharedCacheMap->SharedCacheMapLinks ); // // Make sure the Lazy Writer will wake up, because we // want him to delete this SharedCacheMap. // LazyWriter.OtherWork = TRUE; if (!LazyWriter.ScanActive) { CcScheduleLazyWriteScan(); } CcReleaseMasterLock( OldIrql ); } } else { CcReleaseMasterLock( OldIrql ); } SharedListOwned = FALSE; // // If we did not create this SharedCacheMap, then there is a // possibility that it is in the dirty list. Once we are sure // we have the spinlock, just make sure it is in the clean list // if there are no dirty bytes and the open count is nonzero. // (The latter test is almost guaranteed, of course, but we check // it to be safe.) // } else if (!WeCreated && (SharedCacheMap != NULL)) { if (!SharedListOwned) { CcAcquireMasterLock( &OldIrql ); SharedListOwned = TRUE; } if ((SharedCacheMap->DirtyPages == 0) && (SharedCacheMap->OpenCount != 0)) { RemoveEntryList( &SharedCacheMap->SharedCacheMapLinks ); InsertTailList( &CcCleanSharedCacheMapList, &SharedCacheMap->SharedCacheMapLinks ); } } // // Release global resource // if (SharedListOwned) { CcReleaseMasterLock( OldIrql ); } if (CacheMapToFree != NULL) { ExFreePool(CacheMapToFree); } } DebugTrace(-1, me, "CcInitializeCacheMap -> VOID\n", 0 ); return; }

NTKERNELAPI BOOLEAN CcIsThereDirtyData (  IN PVPB  Vpb  )

Definition at line 362 of file logsup.c. References CcAcquireMasterLock, CcDirtySharedCacheMapList, CcReleaseMasterLock, ClearFlag, _SHARED_CACHE_MAP::DirtyPages, FALSE, _SHARED_CACHE_MAP::FileObject, FlagOn, _FILE_OBJECT::Flags, _SHARED_CACHE_MAP::Flags, FO_TEMPORARY_FILE, IS_CURSOR, SetFlag, _SHARED_CACHE_MAP::SharedCacheMapLinks, _SHARED_CACHE_MAP_LIST_CURSOR::SharedCacheMapLinks, TRUE, _FILE_OBJECT::Vpb, and WRITE_QUEUED. : This routine returns TRUE if the specified Vcb has any unwritten dirty data in the cache. Arguments: Vpb - specifies Vpb to check for Return Value: FALSE - if the Vpb has no dirty data TRUE - if the Vpb has dirty data --*/ { PSHARED_CACHE_MAP SharedCacheMap; KIRQL OldIrql; ULONG LoopsWithLockHeld = 0; // // Synchronize with changes to the SharedCacheMap list. // CcAcquireMasterLock( &OldIrql ); SharedCacheMap = CONTAINING_RECORD( CcDirtySharedCacheMapList.SharedCacheMapLinks.Flink, SHARED_CACHE_MAP, SharedCacheMapLinks ); while (&SharedCacheMap->SharedCacheMapLinks != &CcDirtySharedCacheMapList.SharedCacheMapLinks) { // // Look at this one if the Vpb matches and if there is dirty data. // For what it's worth, don't worry about dirty data in temporary files, // as that should not concern the caller if it wants to dismount. // if (!FlagOn(SharedCacheMap->Flags, IS_CURSOR) && (SharedCacheMap->FileObject->Vpb == Vpb) && (SharedCacheMap->DirtyPages != 0) && !FlagOn(SharedCacheMap->FileObject->Flags, FO_TEMPORARY_FILE)) { CcReleaseMasterLock( OldIrql ); return TRUE; } // // Make sure we occassionally drop the lock. Set WRITE_QUEUED // to keep the guy from going away, and increment DirtyPages to // keep in in this list. // if ((++LoopsWithLockHeld >= 20) && !FlagOn(SharedCacheMap->Flags, WRITE_QUEUED | IS_CURSOR)) { SetFlag( (volatile ULONG) SharedCacheMap->Flags, WRITE_QUEUED); (volatile ULONG) SharedCacheMap->DirtyPages += 1; CcReleaseMasterLock( OldIrql ); LoopsWithLockHeld = 0; CcAcquireMasterLock( &OldIrql ); ClearFlag( (volatile ULONG) SharedCacheMap->Flags, WRITE_QUEUED); (volatile ULONG) SharedCacheMap->DirtyPages -= 1; } // // Now loop back for the next cache map. // SharedCacheMap = CONTAINING_RECORD( SharedCacheMap->SharedCacheMapLinks.Flink, SHARED_CACHE_MAP, SharedCacheMapLinks ); } CcReleaseMasterLock( OldIrql ); return FALSE; }

NTKERNELAPI 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; }

NTKERNELAPI VOID CcMdlRead (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, OUT PMDL *  MdlChain, OUT PIO_STATUS_BLOCK  IoStatus )

Definition at line 30 of file mdlsup.c. References ASSERT, _PRIVATE_CACHE_MAP::BeyondLastByte1, _PRIVATE_CACHE_MAP::BeyondLastByte2, CcFreeActiveVacb(), CcFreeVirtualAddress(), CcGetVirtualAddress(), CcMdlReadWait, CcMdlReadWaitMiss, CcMissCounter, CcScheduleReadAhead(), CcThrowAway, COMPUTE_PAGES_SPANNED, DebugTrace, DebugTrace2, ExRaiseStatus(), FALSE, _PRIVATE_CACHE_MAP::FileOffset1, _PRIVATE_CACHE_MAP::FileOffset2, _SHARED_CACHE_MAP::FileSize, FlagOn, FO_RANDOM_ACCESS, GetActiveVacb, IoAllocateMdl(), IoFreeMdl(), IoReadAccess, KernelMode, me, mm, MmProbeAndLockPages(), MmResetPageFaultReadAhead, MmSavePageFaultReadAhead, MmSetPageFaultReadAhead, MmUnlockPages(), _SHARED_CACHE_MAP::NeedToZero, _MDL::Next, NULL, PsGetCurrentThread, _PRIVATE_CACHE_MAP::ReadAheadEnabled, _PRIVATE_CACHE_MAP::ReadAheadLength, and TRUE. Referenced by FsRtlMdlReadDev(), and UdfCommonRead(). : This routine attempts to lock the specified file data in the cache and return a description of it in an Mdl along with the correct I/O status. It is *not* safe to call this routine from Dpc level. This routine is synchronous, and raises on errors. As each call returns, the pages described by the Mdl are locked in memory, but not mapped in system space. If the caller needs the pages mapped in system space, then it must map them. Note that each call is a "single shot" which should be followed by a call to CcMdlReadComplete. To resume an Mdl-based transfer, the caller must form one or more subsequent calls to CcMdlRead with appropriately adjusted parameters. 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. MdlChain - On output it returns a pointer to an Mdl chain describing the desired data. Note that even if FALSE is returned, one or more Mdls may have been allocated, as may be ascertained by the IoStatus.Information field (see below). IoStatus - Pointer to standard I/O status block to receive the status for the transfer. (STATUS_SUCCESS guaranteed for cache hits, otherwise the actual I/O status is returned.) The I/O Information Field indicates how many bytes have been successfully locked down in the Mdl Chain. Return Value: None Raises: STATUS_INSUFFICIENT_RESOURCES - If a pool allocation failure occurs. --*/ { PSHARED_CACHE_MAP SharedCacheMap; PPRIVATE_CACHE_MAP PrivateCacheMap; PVOID CacheBuffer; LARGE_INTEGER FOffset; PMDL Mdl = NULL; PMDL MdlTemp; PETHREAD Thread = PsGetCurrentThread(); ULONG SavedState = 0; ULONG OriginalLength = Length; ULONG Information = 0; PVACB Vacb = NULL; ULONG SavedMissCounter = 0; KIRQL OldIrql; ULONG ActivePage; ULONG PageIsDirty; PVACB ActiveVacb = NULL; DebugTrace(+1, me, "CcMdlRead\n", 0 ); DebugTrace( 0, me, " FileObject = %08lx\n", FileObject ); DebugTrace2(0, me, " FileOffset = %08lx, %08lx\n", FileOffset->LowPart, FileOffset->HighPart ); DebugTrace( 0, me, " Length = %08lx\n", Length ); // // Save the current readahead hints. // MmSavePageFaultReadAhead( Thread, &SavedState ); // // Get pointer to SharedCacheMap. // SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; PrivateCacheMap = FileObject->PrivateCacheMap; // // See if we have an active Vacb, that we need to free. // GetActiveVacb( SharedCacheMap, OldIrql, ActiveVacb, ActivePage, PageIsDirty ); // // If there is an end of a page to be zeroed, then free that page now, // so we don't send Greg the uninitialized data... // if ((ActiveVacb != NULL) || (SharedCacheMap->NeedToZero != NULL)) { CcFreeActiveVacb( SharedCacheMap, ActiveVacb, ActivePage, PageIsDirty ); } // // If read ahead is enabled, then do the read ahead here so it // overlaps with the copy (otherwise we will do it below). // Note that we are assuming that we will not get ahead of our // current transfer - if read ahead is working it should either // already be in memory or else underway. // if (PrivateCacheMap->ReadAheadEnabled && (PrivateCacheMap->ReadAheadLength[1] == 0)) { CcScheduleReadAhead( FileObject, FileOffset, Length ); } // // Increment performance counters // CcMdlReadWait += 1; // // This is not an exact solution, but when IoPageRead gets a miss, // it cannot tell whether it was CcCopyRead or CcMdlRead, but since // the miss should occur very soon, by loading the pointer here // probably the right counter will get incremented, and in any case, // we hope the errrors average out! // CcMissCounter = &CcMdlReadWaitMiss; FOffset = *FileOffset; // // Check for read past file size, the caller must filter this case out. // ASSERT( ( FOffset.QuadPart + (LONGLONG)Length ) <= SharedCacheMap->FileSize.QuadPart ); // // Put try-finally around the loop to deal with any exceptions // try { // // Not all of the transfer will come back at once, so we have to loop // until the entire transfer is complete. // while (Length != 0) { ULONG ReceivedLength; LARGE_INTEGER BeyondLastByte; // // Map the data and read it in (if necessary) with the // MmProbeAndLockPages call below. // CacheBuffer = CcGetVirtualAddress( SharedCacheMap, FOffset, &Vacb, &ReceivedLength ); if (ReceivedLength > Length) { ReceivedLength = Length; } BeyondLastByte.QuadPart = FOffset.QuadPart + (LONGLONG)ReceivedLength; // // Now attempt to allocate an Mdl to describe the mapped data. // DebugTrace( 0, mm, "IoAllocateMdl:\n", 0 ); DebugTrace( 0, mm, " BaseAddress = %08lx\n", CacheBuffer ); DebugTrace( 0, mm, " Length = %08lx\n", ReceivedLength ); Mdl = IoAllocateMdl( CacheBuffer, ReceivedLength, FALSE, FALSE, NULL ); DebugTrace( 0, mm, " <Mdl = %08lx\n", Mdl ); if (Mdl == NULL) { DebugTrace( 0, 0, "Failed to allocate Mdl\n", 0 ); ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } DebugTrace( 0, mm, "MmProbeAndLockPages:\n", 0 ); DebugTrace( 0, mm, " Mdl = %08lx\n", Mdl ); // // Set to see if the miss counter changes in order to // detect when we should turn on read ahead. // SavedMissCounter += CcMdlReadWaitMiss; MmSetPageFaultReadAhead( Thread, COMPUTE_PAGES_SPANNED( CacheBuffer, ReceivedLength ) - 1); MmProbeAndLockPages( Mdl, KernelMode, IoReadAccess ); SavedMissCounter -= CcMdlReadWaitMiss; // // Unmap the data now, now that the pages are locked down. // CcFreeVirtualAddress( Vacb ); Vacb = NULL; // // Now link the Mdl into the caller's chain // if ( *MdlChain == NULL ) { *MdlChain = Mdl; } else { MdlTemp = CONTAINING_RECORD( *MdlChain, MDL, Next ); while (MdlTemp->Next != NULL) { MdlTemp = MdlTemp->Next; } MdlTemp->Next = Mdl; } Mdl = NULL; // // Assume we did not get all the data we wanted, and set FOffset // to the end of the returned data. // FOffset = BeyondLastByte; // // Update number of bytes transferred. // Information += ReceivedLength; // // Calculate length left to transfer. // Length -= ReceivedLength; } } finally { CcMissCounter = &CcThrowAway; // // Restore the readahead hints. // MmResetPageFaultReadAhead( Thread, SavedState ); if (AbnormalTermination()) { // // We may have failed to allocate an Mdl while still having // data mapped. // if (Vacb != NULL) { CcFreeVirtualAddress( Vacb ); } if (Mdl != NULL) { IoFreeMdl( Mdl ); } // // Otherwise loop to deallocate the Mdls // while (*MdlChain != NULL) { MdlTemp = (*MdlChain)->Next; DebugTrace( 0, mm, "MmUnlockPages/IoFreeMdl:\n", 0 ); DebugTrace( 0, mm, " Mdl = %08lx\n", *MdlChain ); MmUnlockPages( *MdlChain ); IoFreeMdl( *MdlChain ); *MdlChain = MdlTemp; } DebugTrace(-1, me, "CcMdlRead -> Unwinding\n", 0 ); } else { // // Now enable read ahead if it looks like we got any misses, and do // the first one. // if (!FlagOn( FileObject->Flags, FO_RANDOM_ACCESS ) && !PrivateCacheMap->ReadAheadEnabled && (SavedMissCounter != 0)) { PrivateCacheMap->ReadAheadEnabled = TRUE; CcScheduleReadAhead( FileObject, FileOffset, OriginalLength ); } // // Now that we have described our desired read ahead, let's // shift the read history down. // PrivateCacheMap->FileOffset1 = PrivateCacheMap->FileOffset2; PrivateCacheMap->BeyondLastByte1 = PrivateCacheMap->BeyondLastByte2; PrivateCacheMap->FileOffset2 = *FileOffset; PrivateCacheMap->BeyondLastByte2.QuadPart = FileOffset->QuadPart + (LONGLONG)OriginalLength; IoStatus->Status = STATUS_SUCCESS; IoStatus->Information = Information; } } DebugTrace( 0, me, " <MdlChain = %08lx\n", *MdlChain ); DebugTrace2(0, me, " <IoStatus = %08lx, %08lx\n", IoStatus->Status, IoStatus->Information ); DebugTrace(-1, me, "CcMdlRead -> VOID\n", 0 ); return; }

NTKERNELAPI VOID CcMdlReadComplete (  IN PFILE_OBJECT  FileObject, IN PMDL  MdlChain )

Definition at line 381 of file mdlsup.c. References CcMdlReadComplete2(), _DEVICE_OBJECT::DriverObject, _DRIVER_OBJECT::FastIoDispatch, IoGetRelatedDeviceObject(), _FAST_IO_DISPATCH::MdlReadComplete, NULL, and _FAST_IO_DISPATCH::SizeOfFastIoDispatch. Referenced by UdfCompleteMdl(). { PDEVICE_OBJECT DeviceObject; PFAST_IO_DISPATCH FastIoDispatch; DeviceObject = IoGetRelatedDeviceObject( FileObject ); FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; if ((FastIoDispatch != NULL) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlWriteComplete)) && (FastIoDispatch->MdlReadComplete != NULL) && FastIoDispatch->MdlReadComplete( FileObject, MdlChain, DeviceObject )) { NOTHING; } else { CcMdlReadComplete2( FileObject, MdlChain ); } }

NTKERNELAPI VOID CcMdlReadComplete2 (  IN PFILE_OBJECT  FileObject, IN PMDL  MdlChain )

Definition at line 406 of file mdlsup.c. References DebugTrace, IoFreeMdl(), me, mm, MmUnlockPages(), _MDL::Next, and NULL. Referenced by CcMdlReadComplete(), and FsRtlMdlReadCompleteDev(). : This routine must be called at IPL0 after a call to CcMdlRead. The caller must simply supply the address of the MdlChain returned in CcMdlRead. This call does the following: Deletes the MdlChain 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. MdlChain - same as returned from corresponding call to CcMdlRead. Return Value: None. --*/ { PMDL MdlNext; DebugTrace(+1, me, "CcMdlReadComplete\n", 0 ); DebugTrace( 0, me, " FileObject = %08lx\n", FileObject ); DebugTrace( 0, me, " MdlChain = %08lx\n", MdlChain ); // // Deallocate the Mdls // while (MdlChain != NULL) { MdlNext = MdlChain->Next; DebugTrace( 0, mm, "MmUnlockPages/IoFreeMdl:\n", 0 ); DebugTrace( 0, mm, " Mdl = %08lx\n", MdlChain ); MmUnlockPages( MdlChain ); IoFreeMdl( MdlChain ); MdlChain = MdlNext; } DebugTrace(-1, me, "CcMdlReadComplete -> VOID\n", 0 ); }

NTKERNELAPI VOID CcMdlWriteComplete (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN PMDL  MdlChain )

Definition at line 812 of file mdlsup.c. References CcMdlWriteComplete2(), _DEVICE_OBJECT::DriverObject, _DRIVER_OBJECT::FastIoDispatch, IoGetRelatedDeviceObject(), _FAST_IO_DISPATCH::MdlWriteComplete, NULL, and _FAST_IO_DISPATCH::SizeOfFastIoDispatch. { PDEVICE_OBJECT DeviceObject; PFAST_IO_DISPATCH FastIoDispatch; DeviceObject = IoGetRelatedDeviceObject( FileObject ); FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; if ((FastIoDispatch != NULL) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlWriteComplete)) && (FastIoDispatch->MdlWriteComplete != NULL) && FastIoDispatch->MdlWriteComplete( FileObject, FileOffset, MdlChain, DeviceObject )) { NOTHING; } else { CcMdlWriteComplete2( FileObject, FileOffset, MdlChain ); } }

NTKERNELAPI VOID CcMdlWriteComplete2 (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN PMDL  MdlChain )

Definition at line 838 of file mdlsup.c. References CcAcquireMasterLock, CcDecrementOpenCount, CcDirtySharedCacheMapList, CcReleaseMasterLock, CcScheduleLazyWriteScan(), CcSetDirtyInMask(), DebugTrace, _SHARED_CACHE_MAP::DirtyPages, FlagOn, _SHARED_CACHE_MAP::Flags, FO_WRITE_THROUGH, FsRtlNormalizeNtstatus(), IoFreeMdl(), LazyWriter, me, mm, MmFlushSection(), MmUnlockPages(), _MDL::Next, NT_SUCCESS, NTSTATUS(), NULL, _SHARED_CACHE_MAP::OpenCount, _LAZY_WRITER::OtherWork, _LAZY_WRITER::ScanActive, _SHARED_CACHE_MAP_LIST_CURSOR::SharedCacheMapLinks, _SHARED_CACHE_MAP::SharedCacheMapLinks, TRUE, and WRITE_QUEUED. Referenced by CcMdlWriteComplete(), and FsRtlMdlWriteCompleteDev(). : This routine must be called at IPL0 after a call to CcPrepareMdlWrite. The caller supplies the ActualLength of data that it actually wrote into the buffer, which may be less than or equal to the Length specified in CcPrepareMdlWrite. This call does the following: Makes sure the data up to ActualLength eventually gets written. If WriteThrough is FALSE, the data will not be written immediately. If WriteThrough is TRUE, then the data is written synchronously. Unmaps the pages (if mapped), unlocks them and deletes the MdlChain 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 - Original file offset read above. MdlChain - same as returned from corresponding call to CcPrepareMdlWrite. Return Value: None --*/ { PMDL MdlNext; PSHARED_CACHE_MAP SharedCacheMap; LARGE_INTEGER FOffset; IO_STATUS_BLOCK IoStatus; KIRQL OldIrql; NTSTATUS StatusToRaise = STATUS_SUCCESS; DebugTrace(+1, me, "CcMdlWriteComplete\n", 0 ); DebugTrace( 0, me, " FileObject = %08lx\n", FileObject ); DebugTrace( 0, me, " MdlChain = %08lx\n", MdlChain ); SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; // // Deallocate the Mdls // FOffset.QuadPart = *(LONGLONG UNALIGNED *)FileOffset; while (MdlChain != NULL) { MdlNext = MdlChain->Next; DebugTrace( 0, mm, "MmUnlockPages/IoFreeMdl:\n", 0 ); DebugTrace( 0, mm, " Mdl = %08lx\n", MdlChain ); // // Now clear the dirty bits in the Pte and set them in the // Pfn. // MmUnlockPages( MdlChain ); // // Extract the File Offset for this part of the transfer. // if (FlagOn(FileObject->Flags, FO_WRITE_THROUGH)) { MmFlushSection ( FileObject->SectionObjectPointer, &FOffset, MdlChain->ByteCount, &IoStatus, TRUE ); // // If we got an I/O error, remember it. // if (!NT_SUCCESS(IoStatus.Status)) { StatusToRaise = IoStatus.Status; } } else { // // Ignore the only exception (allocation error), and console // ourselves for having tried. // CcSetDirtyInMask( SharedCacheMap, &FOffset, MdlChain->ByteCount ); } FOffset.QuadPart = FOffset.QuadPart + (LONGLONG)(MdlChain->ByteCount); IoFreeMdl( MdlChain ); MdlChain = MdlNext; } // // Now release our open count. // CcAcquireMasterLock( &OldIrql ); CcDecrementOpenCount( SharedCacheMap, 'ldmC' ); if ((SharedCacheMap->OpenCount == 0) && !FlagOn(SharedCacheMap->Flags, WRITE_QUEUED) && (SharedCacheMap->DirtyPages == 0)) { // // Move to the dirty list. // RemoveEntryList( &SharedCacheMap->SharedCacheMapLinks ); InsertTailList( &CcDirtySharedCacheMapList.SharedCacheMapLinks, &SharedCacheMap->SharedCacheMapLinks ); // // Make sure the Lazy Writer will wake up, because we // want him to delete this SharedCacheMap. // LazyWriter.OtherWork = TRUE; if (!LazyWriter.ScanActive) { CcScheduleLazyWriteScan(); } } CcReleaseMasterLock( OldIrql ); // // If we got an I/O error, raise it now. // if (!NT_SUCCESS(StatusToRaise)) { FsRtlNormalizeNtstatus( StatusToRaise, STATUS_UNEXPECTED_IO_ERROR ); } DebugTrace(-1, me, "CcMdlWriteComplete -> TRUE\n", 0 ); return; }

NTKERNELAPI 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; }

NTKERNELAPI 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; }

NTKERNELAPI VOID CcPrepareMdlWrite (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length, OUT PMDL *  MdlChain, OUT PIO_STATUS_BLOCK  IoStatus )

Definition at line 466 of file mdlsup.c. References _SHARED_CACHE_MAP::BcbSpinLock, CcAcquireMasterLock, CcFreeActiveVacb(), CcFreeVirtualAddress(), CcGetVirtualAddress(), CcIncrementOpenCount, CcMapAndRead(), CcReleaseMasterLock, CcSetDirtyInMask(), DebugTrace, DebugTrace2, ExRaiseStatus(), FALSE, GetActiveVacb, IoAllocateMdl(), IoFreeMdl(), IoWriteAccess, KernelMode, me, mm, MmDisablePageFaultClustering, MmEnablePageFaultClustering, MmProbeAndLockPages(), MmUnlockPages(), _SHARED_CACHE_MAP::NeedToZero, _MDL::Next, NULL, PAGE_SIZE, TRUE, _SHARED_CACHE_MAP::ValidDataGoal, VOID(), ZERO_FIRST_PAGE, ZERO_LAST_PAGE, and ZERO_MIDDLE_PAGES. Referenced by FsRtlPrepareMdlWriteDev(). : This routine attempts to lock the specified file data in the cache and return a description of it in an Mdl along with the correct I/O status. Pages to be completely overwritten may be satisfied with emtpy pages. It is *not* safe to call this routine from Dpc level. This call is synchronous and raises on error. When this call returns, the caller may immediately begin to transfer data into the buffers via the Mdl. When the call returns with TRUE, the pages described by the Mdl are locked in memory, but not mapped in system space. If the caller needs the pages mapped in system space, then it must map them. On the subsequent call to CcMdlWriteComplete the pages will be unmapped if they were mapped, and in any case unlocked and the Mdl deallocated. 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. MdlChain - On output it returns a pointer to an Mdl chain describing the desired data. Note that even if FALSE is returned, one or more Mdls may have been allocated, as may be ascertained by the IoStatus.Information field (see below). IoStatus - Pointer to standard I/O status block to receive the status for the in-transfer of the data. (STATUS_SUCCESS guaranteed for cache hits, otherwise the actual I/O status is returned.) The I/O Information Field indicates how many bytes have been successfully locked down in the Mdl Chain. Return Value: None --*/ { PSHARED_CACHE_MAP SharedCacheMap; PVOID CacheBuffer; LARGE_INTEGER FOffset; PMDL Mdl = NULL; PMDL MdlTemp; LARGE_INTEGER Temp; ULONG SavedState = 0; ULONG ZeroFlags = 0; ULONG Information = 0; KIRQL OldIrql; ULONG ActivePage; ULONG PageIsDirty; PVACB Vacb = NULL; DebugTrace(+1, me, "CcPrepareMdlWrite\n", 0 ); DebugTrace( 0, me, " FileObject = %08lx\n", FileObject ); DebugTrace2(0, me, " FileOffset = %08lx, %08lx\n", FileOffset->LowPart, FileOffset->HighPart ); DebugTrace( 0, me, " Length = %08lx\n", Length ); // // Get pointer to SharedCacheMap. // SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; // // See if we have an active Vacb, that we need to free. // GetActiveVacb( SharedCacheMap, OldIrql, Vacb, ActivePage, PageIsDirty ); // // If there is an end of a page to be zeroed, then free that page now, // so it does not cause our data to get zeroed. If there is an active // page, free it so we have the correct ValidDataGoal. // if ((Vacb != NULL) || (SharedCacheMap->NeedToZero != NULL)) { CcFreeActiveVacb( SharedCacheMap, Vacb, ActivePage, PageIsDirty ); Vacb = NULL; } FOffset = *FileOffset; // // Put try-finally around the loop to deal with exceptions // try { // // Not all of the transfer will come back at once, so we have to loop // until the entire transfer is complete. // while (Length != 0) { ULONG ReceivedLength; LARGE_INTEGER BeyondLastByte; // // Map and see how much we could potentially access at this // FileOffset, then cut it down if it is more than we need. // CacheBuffer = CcGetVirtualAddress( SharedCacheMap, FOffset, &Vacb, &ReceivedLength ); if (ReceivedLength > Length) { ReceivedLength = Length; } BeyondLastByte.QuadPart = FOffset.QuadPart + (LONGLONG)ReceivedLength; // // At this point we can calculate the ZeroFlags. // // // We can always zero middle pages, if any. // ZeroFlags = ZERO_MIDDLE_PAGES; // // See if we are completely overwriting the first or last page. // if (((FOffset.LowPart & (PAGE_SIZE - 1)) == 0) && (ReceivedLength >= PAGE_SIZE)) { ZeroFlags |= ZERO_FIRST_PAGE; } if ((BeyondLastByte.LowPart & (PAGE_SIZE - 1)) == 0) { ZeroFlags |= ZERO_LAST_PAGE; } // // See if the entire transfer is beyond valid data length, // or at least starting from the second page. // Temp = FOffset; Temp.LowPart &= ~(PAGE_SIZE -1); ExAcquireFastLock( &SharedCacheMap->BcbSpinLock, &OldIrql ); Temp.QuadPart = SharedCacheMap->ValidDataGoal.QuadPart - Temp.QuadPart; ExReleaseFastLock( &SharedCacheMap->BcbSpinLock, OldIrql ); if (Temp.QuadPart <= 0) { ZeroFlags |= ZERO_FIRST_PAGE | ZERO_MIDDLE_PAGES | ZERO_LAST_PAGE; } else if ((Temp.HighPart == 0) && (Temp.LowPart <= PAGE_SIZE)) { ZeroFlags |= ZERO_MIDDLE_PAGES | ZERO_LAST_PAGE; } (VOID)CcMapAndRead( SharedCacheMap, &FOffset, ReceivedLength, ZeroFlags, TRUE, CacheBuffer ); // // Now attempt to allocate an Mdl to describe the mapped data. // DebugTrace( 0, mm, "IoAllocateMdl:\n", 0 ); DebugTrace( 0, mm, " BaseAddress = %08lx\n", CacheBuffer ); DebugTrace( 0, mm, " Length = %08lx\n", ReceivedLength ); Mdl = IoAllocateMdl( CacheBuffer, ReceivedLength, FALSE, FALSE, NULL ); DebugTrace( 0, mm, " <Mdl = %08lx\n", Mdl ); if (Mdl == NULL) { DebugTrace( 0, 0, "Failed to allocate Mdl\n", 0 ); ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } DebugTrace( 0, mm, "MmProbeAndLockPages:\n", 0 ); DebugTrace( 0, mm, " Mdl = %08lx\n", Mdl ); MmDisablePageFaultClustering(&SavedState); MmProbeAndLockPages( Mdl, KernelMode, IoWriteAccess ); MmEnablePageFaultClustering(SavedState); SavedState = 0; // // Now that some data (maybe zeros) is locked in memory and // set dirty, it is safe, and necessary for us to advance // valid data goal, so that we will not subsequently ask // for a zero page. Note if we are extending valid data, // our caller has the file exclusive. // ExAcquireFastLock( &SharedCacheMap->BcbSpinLock, &OldIrql ); if (BeyondLastByte.QuadPart > SharedCacheMap->ValidDataGoal.QuadPart) { SharedCacheMap->ValidDataGoal = BeyondLastByte; } ExReleaseFastLock( &SharedCacheMap->BcbSpinLock, OldIrql ); // // Unmap the data now, now that the pages are locked down. // CcFreeVirtualAddress( Vacb ); Vacb = NULL; // // Now link the Mdl into the caller's chain // if ( *MdlChain == NULL ) { *MdlChain = Mdl; } else { MdlTemp = CONTAINING_RECORD( *MdlChain, MDL, Next ); while (MdlTemp->Next != NULL) { MdlTemp = MdlTemp->Next; } MdlTemp->Next = Mdl; } Mdl = NULL; // // Assume we did not get all the data we wanted, and set FOffset // to the end of the returned data. // FOffset = BeyondLastByte; // // Update number of bytes transferred. // Information += ReceivedLength; // // Calculate length left to transfer. // Length -= ReceivedLength; } } finally { if (AbnormalTermination()) { if (SavedState != 0) { MmEnablePageFaultClustering(SavedState); } if (Vacb != NULL) { CcFreeVirtualAddress( Vacb ); } if (Mdl != NULL) { IoFreeMdl( Mdl ); } // // Otherwise loop to deallocate the Mdls // FOffset = *FileOffset; while (*MdlChain != NULL) { MdlTemp = (*MdlChain)->Next; DebugTrace( 0, mm, "MmUnlockPages/IoFreeMdl:\n", 0 ); DebugTrace( 0, mm, " Mdl = %08lx\n", *MdlChain ); MmUnlockPages( *MdlChain ); // // Extract the File Offset for this part of the transfer, and // tell the lazy writer to write these pages, since we have // marked them dirty. Ignore the only exception (allocation // error), and console ourselves for having tried. // CcSetDirtyInMask( SharedCacheMap, &FOffset, (*MdlChain)->ByteCount ); FOffset.QuadPart = FOffset.QuadPart + (LONGLONG)((*MdlChain)->ByteCount); IoFreeMdl( *MdlChain ); *MdlChain = MdlTemp; } DebugTrace(-1, me, "CcPrepareMdlWrite -> Unwinding\n", 0 ); } else { IoStatus->Status = STATUS_SUCCESS; IoStatus->Information = Information; // // Make sure the SharedCacheMap does not go away while // the Mdl write is in progress. We decrment below. // CcAcquireMasterLock( &OldIrql ); CcIncrementOpenCount( SharedCacheMap, 'ldmP' ); CcReleaseMasterLock( OldIrql ); } } DebugTrace( 0, me, " <MdlChain = %08lx\n", *MdlChain ); DebugTrace(-1, me, "CcPrepareMdlWrite -> VOID\n", 0 ); return; }

NTKERNELAPI 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; }

NTKERNELAPI BOOLEAN CcPurgeCacheSection (  IN PSECTION_OBJECT_POINTERS  SectionObjectPointer, IN PLARGE_INTEGER FileOffset  OPTIONAL, IN ULONG  Length, IN BOOLEAN  UninitializeCacheMaps )

Definition at line 2331 of file fssup.c. References ASSERT, CcAcquireMasterLock, CcCollisionDelay, CcDecrementOpenCount, CcDirtySharedCacheMapList, CcFreeActiveVacb(), CcIncrementOpenCount, CcReleaseMasterLock, CcScheduleLazyWriteScan(), CcUninitializeCacheMap(), CcUnmapVacbArray(), CcWaitOnActiveCount(), DebugTrace, DebugTrace2, _SHARED_CACHE_MAP::DirtyPages, FALSE, _PRIVATE_CACHE_MAP::FileObject, FlagOn, _SHARED_CACHE_MAP::Flags, GetActiveVacbAtDpcLevel, KeDelayExecutionThread(), KernelMode, LazyWriter, me, mm, MmCanFileBeTruncated(), MmPurgeSection(), NULL, _SHARED_CACHE_MAP::OpenCount, _LAZY_WRITER::OtherWork, PAGE_SIZE, _SHARED_CACHE_MAP::PrivateList, _LAZY_WRITER::ScanActive, _SHARED_CACHE_MAP_LIST_CURSOR::SharedCacheMapLinks, _SHARED_CACHE_MAP::SharedCacheMapLinks, TRUE, _SHARED_CACHE_MAP::Vacbs, VOID(), and WRITE_QUEUED. Referenced by CcPurgeAndClearCacheSection(), CcSetFileSizes(), CcUninitializeCacheMap(), CcUnmapAndPurge(), CcZeroEndOfLastPage(), UdfPurgeVolume(), and UdfUpdateVcbPhase0(). : This routine may be called to force a purge of the cache section, even if it is cached. Note, if a user has the file mapped, then the purge will *not* take effect, and this must be considered part of normal application interaction. The purpose of purge is to throw away potentially nonzero data, so that it will be read in again and presumably zeroed. This is not really a security issue, but rather an effort to not confuse the application when it sees nonzero data. We cannot help the fact that a user-mapped view forces us to hang on to stale data. This routine is intended to be called whenever previously written data is being truncated from the file, and the file is not being deleted. The file must be acquired exclusive in order to call this routine. Arguments: SectionObjectPointer - A pointer to the Section Object Pointers structure in the nonpaged Fcb. FileOffset - Offset from which file should be purged - rounded down to page boundary. If NULL, purge the entire file. Length - Defines the length of the byte range to purge, starting at FileOffset. This parameter is ignored if FileOffset is specified as NULL. If FileOffset is specified and Length is 0, then purge from FileOffset to the end of the file. UninitializeCacheMaps - If TRUE, we should uninitialize all the private cache maps before purging the data. ReturnValue: FALSE - if the section was not successfully purged TRUE - if the section was successfully purged --*/ { KIRQL OldIrql; PSHARED_CACHE_MAP SharedCacheMap; PPRIVATE_CACHE_MAP PrivateCacheMap; ULONG ActivePage; ULONG PageIsDirty; BOOLEAN PurgeWorked = TRUE; PVACB Vacb = NULL; DebugTrace(+1, me, "CcPurgeCacheSection:\n", 0 ); DebugTrace( 0, mm, " SectionObjectPointer = %08lx\n", SectionObjectPointer ); DebugTrace2(0, me, " FileOffset = %08lx, %08lx\n", ARGUMENT_PRESENT(FileOffset) ? FileOffset->LowPart : 0, ARGUMENT_PRESENT(FileOffset) ? FileOffset->HighPart : 0 ); DebugTrace( 0, me, " Length = %08lx\n", Length ); // // If you want us to uninitialize cache maps, the RtlZeroMemory paths // below depend on actually having to purge something after zeroing. // ASSERT(!UninitializeCacheMaps || (Length == 0) || (Length >= PAGE_SIZE * 2)); // // Serialize Creation/Deletion of all Shared CacheMaps // CcAcquireMasterLock( &OldIrql ); // // Get pointer to SharedCacheMap via File Object. // SharedCacheMap = SectionObjectPointer->SharedCacheMap; // // Increment open count to make sure the SharedCacheMap stays around, // then release the spinlock so that we can call Mm. // if (SharedCacheMap != NULL) { CcIncrementOpenCount( SharedCacheMap, 'scPS' ); // // If there is an active Vacb, then nuke it now (before waiting!). // GetActiveVacbAtDpcLevel( SharedCacheMap, Vacb, ActivePage, PageIsDirty ); } CcReleaseMasterLock( OldIrql ); if (Vacb != NULL) { CcFreeActiveVacb( SharedCacheMap, Vacb, ActivePage, PageIsDirty ); } // // Use try-finally to insure cleanup of the Open Count and Vacb on the // way out. // try { // // Increment open count to make sure the SharedCacheMap stays around, // then release the spinlock so that we can call Mm. // if (SharedCacheMap != NULL) { // // Now loop to make sure that no one is currently caching the file. // if (UninitializeCacheMaps) { while (!IsListEmpty( &SharedCacheMap->PrivateList )) { PrivateCacheMap = CONTAINING_RECORD( SharedCacheMap->PrivateList.Flink, PRIVATE_CACHE_MAP, PrivateLinks ); CcUninitializeCacheMap( PrivateCacheMap->FileObject, NULL, NULL ); } } // // Now, let's unmap and purge here. // // We still need to wait for any dangling cache read or writes. // // In fact we have to loop and wait because the lazy writer can // sneak in and do an CcGetVirtualAddressIfMapped, and we are not // synchronized. // while ((SharedCacheMap->Vacbs != NULL) && !CcUnmapVacbArray( SharedCacheMap, FileOffset, Length, FALSE )) { CcWaitOnActiveCount( SharedCacheMap ); } } // // Purge failures are extremely rare if there are no user mapped sections. // However, it is possible that we will get one from our own mapping, if // the file is being lazy deleted from a previous open. For that case // we wait here until the purge succeeds, so that we are not left with // old user file data. Although Length is actually invariant in this loop, // we do need to keep checking that we are allowed to truncate in case a // user maps the file during a delay. // while (!(PurgeWorked = MmPurgeSection(SectionObjectPointer, FileOffset, Length, (BOOLEAN)((SharedCacheMap !=NULL) && ARGUMENT_PRESENT(FileOffset)))) && (Length == 0) && MmCanFileBeTruncated(SectionObjectPointer, FileOffset)) { (VOID)KeDelayExecutionThread( KernelMode, FALSE, &CcCollisionDelay ); } } finally { // // Reduce the open count on the SharedCacheMap if there was one. // if (SharedCacheMap != NULL) { // // Serialize again to decrement the open count. // CcAcquireMasterLock( &OldIrql ); CcDecrementOpenCount( SharedCacheMap, 'scPF' ); if ((SharedCacheMap->OpenCount == 0) && !FlagOn(SharedCacheMap->Flags, WRITE_QUEUED) && (SharedCacheMap->DirtyPages == 0)) { // // Move to the dirty list. // RemoveEntryList( &SharedCacheMap->SharedCacheMapLinks ); InsertTailList( &CcDirtySharedCacheMapList.SharedCacheMapLinks, &SharedCacheMap->SharedCacheMapLinks ); // // Make sure the Lazy Writer will wake up, because we // want him to delete this SharedCacheMap. // LazyWriter.OtherWork = TRUE; if (!LazyWriter.ScanActive) { CcScheduleLazyWriteScan(); } } CcReleaseMasterLock( OldIrql ); } } DebugTrace(-1, me, "CcPurgeCacheSection -> %02lx\n", PurgeWorked ); return PurgeWorked; }

NTKERNELAPI PVOID CcRemapBcb (  IN PVOID  Bcb  )

Definition at line 5024 of file cachesub.c. References ASSERT, CACHE_NTC_BCB, CACHE_NTC_OBCB, CcAcquireVacbLock, CcBeyondVacbs, CcReleaseVacbLock, CcVacbs, and _VACB::Overlay. : This routine may be called by a file system to map a Bcb an additional time in order to preserve it through several calls that perform additional maps and unpins. Arguments: Bcb - Supplies a pointer to a previously returned Bcb. Return Value: Bcb with read-only indicator. --*/ { KIRQL OldIrql; PVACB Vacb; // // Remove read-only bit // Bcb = (PVOID) ((ULONG_PTR)Bcb & ~1); if (((PBCB)Bcb)->NodeTypeCode == CACHE_NTC_OBCB) { // // If this is an overlapped BCB, use the first Vacb in the // array // Vacb = ((POBCB)Bcb)->Bcbs[0]->Vacb; } else if (((PBCB)Bcb)->NodeTypeCode == CACHE_NTC_BCB) { // // If this is a BCB, extract the Vcb from it // Vacb = ((PBCB)Bcb)->Vacb; } else { // // Otherwise, there is no signature to match. Assume // it is a Vacb. // Vacb = (PVACB) Bcb; } ASSERT((Vacb >= CcVacbs) && (Vacb < CcBeyondVacbs)); // // Safely bump the active count // CcAcquireVacbLock( &OldIrql ); Vacb->Overlay.ActiveCount += 1; CcReleaseVacbLock( OldIrql ); return (PVOID) ((ULONG_PTR)Vacb | 1); }

NTKERNELAPI VOID CcRepinBcb (  IN PVOID  Bcb  )

Definition at line 5101 of file cachesub.c. : This routine may be called by a file system to pin a Bcb an additional time in order to reserve it for Write Through or error recovery. Typically the file system would do this the first time that it sets a pinned buffer dirty while processing a WriteThrough request, or any time that it determines that a buffer will be required for WriteThrough. The call to this routine must be followed by a call to CcUnpinRepinnedBcb. CcUnpinRepinnedBcb should normally be called during request completion after all other resources have been released. CcUnpinRepinnedBcb synchronously writes the buffer (for WriteThrough requests) and performs the matching unpin for this call. Arguments: Bcb - Supplies a pointer to a previously pinned Bcb Return Value: None. --*/ { KIRQL OldIrql; ExAcquireFastLock( &((PBCB)Bcb)->SharedCacheMap->BcbSpinLock, &OldIrql ); ((PBCB)Bcb)->PinCount += 1; ExReleaseFastLock( &((PBCB)Bcb)->SharedCacheMap->BcbSpinLock, OldIrql ); }

NTKERNELAPI VOID CcScheduleReadAhead (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  FileOffset, IN ULONG  Length )

Definition at line 1253 of file cachesub.c. References ASSERT, _PRIVATE_CACHE_MAP::BeyondLastByte1, _PRIVATE_CACHE_MAP::BeyondLastByte2, CcAcquireMasterLock, CcAllocateWorkQueueEntry, CcExpressWorkQueue, CcIncrementOpenCount, CcPostWorkQueue(), CcReleaseMasterLock, DebugTrace, DebugTrace2, DISABLE_READ_AHEAD, FALSE, _PRIVATE_CACHE_MAP::FileOffset1, _PRIVATE_CACHE_MAP::FileOffset2, FlagOn, _SHARED_CACHE_MAP::Flags, FO_SEQUENTIAL_ONLY, _WORK_QUEUE_ENTRY::Function, me, NOISE_BITS, NULL, ObReferenceObject, PAGE_SIZE, _WORK_QUEUE_ENTRY::Parameters, PWORK_QUEUE_ENTRY, ReadAhead, _PRIVATE_CACHE_MAP::ReadAheadActive, _PRIVATE_CACHE_MAP::ReadAheadLength, _PRIVATE_CACHE_MAP::ReadAheadMask, _PRIVATE_CACHE_MAP::ReadAheadOffset, _PRIVATE_CACHE_MAP::ReadAheadSpinLock, ROUND_TO_PAGES, and TRUE. Referenced by CcCopyRead(), CcFastCopyRead(), and CcMdlRead(). : This routine is called by Copy Read and Mdl Read file system routines to perform common Read Ahead processing. The input parameters describe the current read which has just been completed, or perhaps only started in the case of Mdl Reads. Based on these parameters, an assessment is made on how much data should be read ahead, and whether that data has already been read ahead. The processing is divided into two parts: CALCULATE READ AHEAD REQUIREMENTS (CcScheduleReadAhead) PERFORM READ AHEAD (CcPerformReadAhead) File systems should always call CcReadAhead, which will conditionally call CcScheduleReadAhead (if the read is large enough). If such a call determines that there is read ahead work to do, and no read ahead is currently active, then it will set ReadAheadActive and schedule read ahead to be peformed by the Lazy Writer, who will call CcPeformReadAhead. Arguments: FileObject - supplies pointer to FileObject on which readahead should be considered. FileOffset - supplies the FileOffset at which the last read just occurred. Length - supplies the length of the last read. Return Value: None --*/ { LARGE_INTEGER NewOffset; LARGE_INTEGER NewBeyond; LARGE_INTEGER FileOffset1, FileOffset2; KIRQL OldIrql; PSHARED_CACHE_MAP SharedCacheMap; PPRIVATE_CACHE_MAP PrivateCacheMap; PWORK_QUEUE_ENTRY WorkQueueEntry; ULONG ReadAheadSize; BOOLEAN Changed = FALSE; DebugTrace(+1, me, "CcScheduleReadAhead:\n", 0 ); DebugTrace2(0, me, " FileOffset = %08lx, %08lx\n", FileOffset->LowPart, FileOffset->HighPart ); DebugTrace( 0, me, " Length = %08lx\n", Length ); SharedCacheMap = *(PSHARED_CACHE_MAP *)((PCHAR)FileObject->SectionObjectPointer + sizeof(PVOID)); PrivateCacheMap = FileObject->PrivateCacheMap; if ((PrivateCacheMap == NULL) || (SharedCacheMap == NULL) || FlagOn(SharedCacheMap->Flags, DISABLE_READ_AHEAD)) { DebugTrace(-1, me, "CcScheduleReadAhead -> VOID (Nooped)\n", 0 ); return; } // // Round boundaries of transfer up to some greater granularity, so that // sequential reads will be recognized even if a few bytes are skipped // between records. // NewOffset = *FileOffset; NewBeyond.QuadPart = FileOffset->QuadPart + (LONGLONG)Length; // // Find the next read ahead boundary beyond the current read. // ReadAheadSize = (Length + PrivateCacheMap->ReadAheadMask) & ~PrivateCacheMap->ReadAheadMask; FileOffset2.QuadPart = NewBeyond.QuadPart + (LONGLONG)ReadAheadSize; FileOffset2.LowPart &= ~PrivateCacheMap->ReadAheadMask; // // CALCULATE READ AHEAD REQUIREMENTS // // // Take out the ReadAhead spinlock to synchronize our read ahead decision. // ExAcquireSpinLock( &PrivateCacheMap->ReadAheadSpinLock, &OldIrql ); // // Read Ahead Case 0. // // Sequential-only hint in the file object. For this case we will // try and always keep two read ahead granularities read ahead from // and including the end of the current transfer. This case has the // lowest overhead, and the code is completely immune to how the // caller skips around. Sequential files use ReadAheadOffset[1] in // the PrivateCacheMap as their "high water mark". // if (FlagOn(FileObject->Flags, FO_SEQUENTIAL_ONLY)) { // // If the next boundary is greater than or equal to the high-water mark, // then read ahead. // if (FileOffset2.QuadPart >= PrivateCacheMap->ReadAheadOffset[1].QuadPart) { // // On the first read if we are using a large read ahead granularity, // and the read did not get it all, we will just get the rest of the // first data we want. // if ((FileOffset->QuadPart == 0) && (PrivateCacheMap->ReadAheadMask > (PAGE_SIZE - 1)) && ((Length + PAGE_SIZE - 1) <= PrivateCacheMap->ReadAheadMask)) { FileOffset1.QuadPart = (LONGLONG)( ROUND_TO_PAGES(Length) ); PrivateCacheMap->ReadAheadLength[0] = ReadAheadSize - FileOffset1.LowPart; FileOffset2.QuadPart = (LONGLONG)ReadAheadSize; // // Calculate the next read ahead boundary. // } else { FileOffset1.QuadPart = PrivateCacheMap->ReadAheadOffset[1].QuadPart + (LONGLONG)ReadAheadSize; // // If the end of the current read is actually beyond where we would // normally do our read ahead, then we have fallen behind, and we must // advance to that spot. // if (FileOffset2.QuadPart > FileOffset1.QuadPart) { FileOffset1 = FileOffset2; } PrivateCacheMap->ReadAheadLength[0] = ReadAheadSize; FileOffset2.QuadPart = FileOffset1.QuadPart + (LONGLONG)ReadAheadSize; } // // Now issue the next two read aheads. // PrivateCacheMap->ReadAheadOffset[0] = FileOffset1; PrivateCacheMap->ReadAheadOffset[1] = FileOffset2; PrivateCacheMap->ReadAheadLength[1] = ReadAheadSize; Changed = TRUE; } // // Read Ahead Case 1. // // If this is the third of three sequential reads, then we will see if // we can read ahead. Note that if the first read to a file is to // offset 0, it passes this test. // } else if ((NewOffset.HighPart == PrivateCacheMap->BeyondLastByte2.HighPart) && ((NewOffset.LowPart & ~NOISE_BITS) == (PrivateCacheMap->BeyondLastByte2.LowPart & ~NOISE_BITS)) && (PrivateCacheMap->FileOffset2.HighPart == PrivateCacheMap->BeyondLastByte1.HighPart) && ((PrivateCacheMap->FileOffset2.LowPart & ~NOISE_BITS) == (PrivateCacheMap->BeyondLastByte1.LowPart & ~NOISE_BITS))) { // // On the first read if we are using a large read ahead granularity, // and the read did not get it all, we will just get the rest of the // first data we want. // if ((FileOffset->QuadPart == 0) && (PrivateCacheMap->ReadAheadMask > (PAGE_SIZE - 1)) && ((Length + PAGE_SIZE - 1) <= PrivateCacheMap->ReadAheadMask)) { FileOffset2.QuadPart = (LONGLONG)( ROUND_TO_PAGES(Length) ); } // // Round read offset to next read ahead boundary. // else { FileOffset2.QuadPart = NewBeyond.QuadPart + (LONGLONG)ReadAheadSize; FileOffset2.LowPart &= ~PrivateCacheMap->ReadAheadMask; } // // Set read ahead length to be the same as for the most recent read, // up to our max. // if (FileOffset2.QuadPart != PrivateCacheMap->ReadAheadOffset[1].QuadPart) { ASSERT( FileOffset2.HighPart >= 0 ); Changed = TRUE; PrivateCacheMap->ReadAheadOffset[1] = FileOffset2; PrivateCacheMap->ReadAheadLength[1] = ReadAheadSize; } } // // Read Ahead Case 2. // // If this is the third read following a particular stride, then we // will see if we can read ahead. One example of an application that // might do this is a spreadsheet. Note that this code even works // for negative strides. // else if ( ( NewOffset.QuadPart - PrivateCacheMap->FileOffset2.QuadPart ) == ( PrivateCacheMap->FileOffset2.QuadPart - PrivateCacheMap->FileOffset1.QuadPart )) { // // According to the current stride, the next offset will be: // // NewOffset + (NewOffset - FileOffset2) // // which is the same as: // // (NewOffset * 2) - FileOffset2 // FileOffset2.QuadPart = ( NewOffset.QuadPart << 1 ) - PrivateCacheMap->FileOffset2.QuadPart; // // If our stride is going backwards through the file, we // have to detect the case where the next step would wrap. // if (FileOffset2.HighPart >= 0) { // // The read ahead length must be extended by the same amount that // we will round the PrivateCacheMap->ReadAheadOffset down. // Length += FileOffset2.LowPart & (PAGE_SIZE - 1); // // Now round the PrivateCacheMap->ReadAheadOffset down. // FileOffset2.LowPart &= ~(PAGE_SIZE - 1); PrivateCacheMap->ReadAheadOffset[1] = FileOffset2; // // Round to page boundary. // PrivateCacheMap->ReadAheadLength[1] = (ULONG) ROUND_TO_PAGES(Length); Changed = TRUE; } } // // Get out if the ReadAhead requirements did not change. // if (!Changed || PrivateCacheMap->ReadAheadActive) { DebugTrace( 0, me, "Read ahead already in progress or no change\n", 0 ); ExReleaseSpinLock( &PrivateCacheMap->ReadAheadSpinLock, OldIrql ); return; } // // Otherwise, we will proceed and try to schedule the read ahead // ourselves. // PrivateCacheMap->ReadAheadActive = TRUE; // // Release spin lock on way out // ExReleaseSpinLock( &PrivateCacheMap->ReadAheadSpinLock, OldIrql ); // // Queue the read ahead request to the Lazy Writer's work queue. // DebugTrace( 0, me, "Queueing read ahead to worker thread\n", 0 ); WorkQueueEntry = CcAllocateWorkQueueEntry(); // // If we failed to allocate a work queue entry, then, we will // quietly bag it. Read ahead is only an optimization, and // no one ever requires that it occur. // if (WorkQueueEntry != NULL) { // // We must reference this file object so that it cannot go away // until we finish Read Ahead processing in the Worker Thread. // ObReferenceObject ( FileObject ); // // Increment open count to make sure the SharedCacheMap stays around. // CcAcquireMasterLock( &OldIrql ); CcIncrementOpenCount( SharedCacheMap, 'adRQ' ); CcReleaseMasterLock( OldIrql ); WorkQueueEntry->Function = (UCHAR)ReadAhead; WorkQueueEntry->Parameters.Read.FileObject = FileObject; CcPostWorkQueue( WorkQueueEntry, &CcExpressWorkQueue ); } // // If we failed to allocate a Work Queue Entry, or all of the pages // are resident we must set the active flag false. // else { ExAcquireFastLock( &PrivateCacheMap->ReadAheadSpinLock, &OldIrql ); PrivateCacheMap->ReadAheadActive = FALSE; ExReleaseFastLock( &PrivateCacheMap->ReadAheadSpinLock, OldIrql ); } DebugTrace(-1, me, "CcScheduleReadAhead -> VOID\n", 0 ); return; }

NTKERNELAPI VOID CcSetAdditionalCacheAttributes (  IN PFILE_OBJECT  FileObject, IN BOOLEAN  DisableReadAhead, IN BOOLEAN  DisableWriteBehind )

Definition at line 32 of file logsup.c. References CcAcquireMasterLock, CcReleaseMasterLock, ClearFlag, DISABLE_READ_AHEAD, DISABLE_WRITE_BEHIND, _SHARED_CACHE_MAP::Flags, MODIFIED_WRITE_DISABLED, and SetFlag. Referenced by LfsInitializeLogFile(), and LfsOpenLogFile(). : This routine supports the setting of disable read ahead or disable write behind flags to control Cache Manager operation. This routine may be called any time after calling CcInitializeCacheMap. Initially both read ahead and write behind are enabled. Note that the state of both of these flags must be specified on each call to this routine. Arguments: FileObject - File object for which the respective flags are to be set. DisableReadAhead - FALSE to enable read ahead, TRUE to disable it. DisableWriteBehind - FALSE to enable write behind, TRUE to disable it. Return Value: None. --*/ { PSHARED_CACHE_MAP SharedCacheMap; KIRQL OldIrql; // // Get pointer to SharedCacheMap. // SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; // // Now set the flags and return. // CcAcquireMasterLock( &OldIrql ); if (DisableReadAhead) { SetFlag(SharedCacheMap->Flags, DISABLE_READ_AHEAD); } else { ClearFlag(SharedCacheMap->Flags, DISABLE_READ_AHEAD); } if (DisableWriteBehind) { SetFlag(SharedCacheMap->Flags, DISABLE_WRITE_BEHIND | MODIFIED_WRITE_DISABLED); } else { ClearFlag(SharedCacheMap->Flags, DISABLE_WRITE_BEHIND); } CcReleaseMasterLock( OldIrql ); }

NTKERNELAPI 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 ); } }

NTKERNELAPI VOID CcSetDirtyPageThreshold (  IN PFILE_OBJECT  FileObject, IN ULONG  DirtyPageThreshold )

Definition at line 2747 of file fssup.c. References _SHARED_CACHE_MAP::DirtyPageThreshold, FlagOn, FSRTL_FLAG_LIMIT_MODIFIED_PAGES, NULL, and SetFlag. : This routine may be called to set a dirty page threshold for this stream. The write throttling will kick in whenever the file system attempts to exceed the dirty page threshold for this file. Arguments: FileObject - Supplies file object for the stream DirtyPageThreshold - Supplies the dirty page threshold for this stream, or 0 for no threshold. Return Value: None Environment: The caller must guarantee exclusive access to the FsRtl header flags, for example, by calling this routine once during create of the structure containing the header. Then it would call the routine again when actually caching the stream. --*/ { KIRQL OldIrql; PSHARED_CACHE_MAP SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; if (SharedCacheMap != NULL) { SharedCacheMap->DirtyPageThreshold = DirtyPageThreshold; } // // Test the flag before setting, in case the caller is no longer properly // synchronized. // if (!FlagOn(((PFSRTL_COMMON_FCB_HEADER)(FileObject->FsContext))->Flags, FSRTL_FLAG_LIMIT_MODIFIED_PAGES)) { SetFlag(((PFSRTL_COMMON_FCB_HEADER)(FileObject->FsContext))->Flags, FSRTL_FLAG_LIMIT_MODIFIED_PAGES); } }

NTKERNELAPI VOID CcSetDirtyPinnedData (  IN PVOID  BcbVoid, IN PLARGE_INTEGER Lsn  OPTIONAL )

Definition at line 2560 of file cachesub.c. References ASSERT, _SHARED_CACHE_MAP::BcbSpinLock, CACHE_NTC_OBCB, CcAcquireMasterLockAtDpcLevel, CcDirtySharedCacheMapList, CcReleaseMasterLockFromDpcLevel, CcScheduleLazyWriteScan(), CcTotalDirtyPages, DebugTrace, _SHARED_CACHE_MAP::DirtyPages, DISABLE_WRITE_BEHIND, FlagOn, _SHARED_CACHE_MAP::Flags, LazyWriter, me, NULL, PAGE_SHIFT, POBCB, _LAZY_WRITER::ScanActive, _SHARED_CACHE_MAP_LIST_CURSOR::SharedCacheMapLinks, _SHARED_CACHE_MAP::SharedCacheMapLinks, TRUE, and _SHARED_CACHE_MAP::ValidDataGoal. Referenced by CcCopyWrite(), CcPreparePinWrite(), CcReleaseByteRangeFromWrite(), CcUnpinRepinnedBcb(), CcZeroData(), LfsFlushLfcb(), and LfsFlushLogPage(). : This routine may be called to set a Bcb (returned by CcPinFileData) dirty, and a candidate for the Lazy Writer. All Bcbs should be set dirty by calling this routine, even if they are to be flushed another way. Arguments: Bcb - Supplies a pointer to a pinned (by CcPinFileData) Bcb, to be set dirty. Lsn - Lsn to be remembered with page. Return Value: None --*/ { PBCB Bcbs[2]; PBCB *BcbPtrPtr; KIRQL OldIrql; PSHARED_CACHE_MAP SharedCacheMap; DebugTrace(+1, me, "CcSetDirtyPinnedData: Bcb = %08lx\n", BcbVoid ); // // Assume this is a normal Bcb, and set up for loop below. // Bcbs[0] = (PBCB)BcbVoid; Bcbs[1] = NULL; BcbPtrPtr = &Bcbs[0]; // // If it is an overlap Bcb, then point into the Bcb vector // for the loop. // if (Bcbs[0]->NodeTypeCode == CACHE_NTC_OBCB) { BcbPtrPtr = &((POBCB)Bcbs[0])->Bcbs[0]; } // // Loop to set all Bcbs dirty // while (*BcbPtrPtr != NULL) { Bcbs[0] = *(BcbPtrPtr++); // // Should be no ReadOnly Bcbs // ASSERT(((ULONG_PTR)Bcbs[0] & 1) != 1); SharedCacheMap = Bcbs[0]->SharedCacheMap; // // We have to acquire the shared cache map list, because we // may be changing lists. // ExAcquireSpinLock( &SharedCacheMap->BcbSpinLock, &OldIrql ); if (!Bcbs[0]->Dirty) { ULONG Pages = Bcbs[0]->ByteLength >> PAGE_SHIFT; // // Set dirty to keep the Bcb from going away until // it is set Undirty, and assign the next modification time stamp. // Bcbs[0]->Dirty = TRUE; // // Initialize the OldestLsn field. // if (ARGUMENT_PRESENT(Lsn)) { Bcbs[0]->OldestLsn = *Lsn; Bcbs[0]->NewestLsn = *Lsn; } // // Move it to the dirty list if these are the first dirty pages, // and this is not disabled for write behind. // // Increase the count of dirty bytes in the shared cache map. // CcAcquireMasterLockAtDpcLevel(); if ((SharedCacheMap->DirtyPages == 0) && !FlagOn(SharedCacheMap->Flags, DISABLE_WRITE_BEHIND)) { // // If the lazy write scan is not active, then start it. // if (!LazyWriter.ScanActive) { CcScheduleLazyWriteScan(); } RemoveEntryList( &SharedCacheMap->SharedCacheMapLinks ); InsertTailList( &CcDirtySharedCacheMapList.SharedCacheMapLinks, &SharedCacheMap->SharedCacheMapLinks ); } SharedCacheMap->DirtyPages += Pages; CcTotalDirtyPages += Pages; CcReleaseMasterLockFromDpcLevel(); } // // If this Lsn happens to be older/newer than the ones we have stored, then // change it. // if (ARGUMENT_PRESENT(Lsn)) { if ((Bcbs[0]->OldestLsn.QuadPart == 0) || (Lsn->QuadPart < Bcbs[0]->OldestLsn.QuadPart)) { Bcbs[0]->OldestLsn = *Lsn; } if (Lsn->QuadPart > Bcbs[0]->NewestLsn.QuadPart) { Bcbs[0]->NewestLsn = *Lsn; } } // // See if we need to advance our goal for ValidDataLength. // if ( Bcbs[0]->BeyondLastByte.QuadPart > SharedCacheMap->ValidDataGoal.QuadPart ) { SharedCacheMap->ValidDataGoal = Bcbs[0]->BeyondLastByte; } ExReleaseSpinLock( &SharedCacheMap->BcbSpinLock, OldIrql ); } DebugTrace(-1, me, "CcSetDirtyPinnedData -> VOID\n", 0 ); }

NTKERNELAPI VOID CcSetFileSizes (  IN PFILE_OBJECT  FileObject, IN PCC_FILE_SIZES  FileSizes )

Definition at line 1821 of file fssup.c. References CcAcquireMasterLock, CcDecrementOpenCount, CcDeleteMbcb(), CcDirtySharedCacheMapList, CcExtendVacbArray(), CcFreeActiveVacb(), CcIncrementOpenCount, CcPurgeAndClearCacheSection(), CcPurgeCacheSection(), CcReleaseMasterLock, CcScheduleLazyWriteScan(), DebugTrace, DebugTrace2, DEFAULT_EXTEND_MODULO, _SHARED_CACHE_MAP::DirtyPages, ExRaiseStatus(), FALSE, _SHARED_CACHE_MAP::FileSize, FlagOn, _SHARED_CACHE_MAP::Flags, FsRtlNormalizeNtstatus(), GetActiveVacbAtDpcLevel, LazyWriter, _SHARED_CACHE_MAP::Mbcb, me, mm, MmExtendSection(), MmFlushSection(), _SHARED_CACHE_MAP::NeedToZero, NT_SUCCESS, NTSTATUS(), NULL, _SHARED_CACHE_MAP::OpenCount, _LAZY_WRITER::OtherWork, PAGE_SIZE, PIN_ACCESS, _LAZY_WRITER::ScanActive, _SHARED_CACHE_MAP::Section, _SHARED_CACHE_MAP::SectionSize, _SHARED_CACHE_MAP_LIST_CURSOR::SharedCacheMapLinks, _SHARED_CACHE_MAP::SharedCacheMapLinks, Status, TRUE, _SHARED_CACHE_MAP::VacbActiveCount, _SHARED_CACHE_MAP::ValidDataGoal, _SHARED_CACHE_MAP::ValidDataLength, and WRITE_QUEUED. Referenced by UdfLookupMetaVsnOfExtent(), and UdfUpdateVcbPhase0(). : This routine must be called whenever a file has been extended to reflect this extension in the cache maps and underlying section. Calling this routine has a benign effect if the current size of the section is already greater than or equal to the new AllocationSize. This routine must also be called whenever the FileSize for a file changes to reflect these changes in the Cache Manager. This routine seems rather large, but in the normal case it only acquires a spinlock, updates some fields, and exits. Less often it will either extend the section, or truncate/purge the file, but it would be unexpected to do both. On the other hand, the idea of this routine is that it does "everything" required when AllocationSize or FileSize change. Arguments: FileObject - A file object for which CcInitializeCacheMap has been previously called. FileSizes - A pointer to AllocationSize, FileSize and ValidDataLength for the file. AllocationSize is ignored if it is not larger than the current section size (i.e., it is ignored unless it has grown). ValidDataLength is not used. Return Value: None --*/ { LARGE_INTEGER NewSectionSize; LARGE_INTEGER NewFileSize; LARGE_INTEGER NewValidDataLength; IO_STATUS_BLOCK IoStatus; PSHARED_CACHE_MAP SharedCacheMap; NTSTATUS Status; KIRQL OldIrql; PVACB ActiveVacb; ULONG ActivePage; ULONG PageIsDirty; DebugTrace(+1, me, "CcSetFileSizes:\n", 0 ); DebugTrace( 0, me, " FileObject = %08lx\n", FileObject ); DebugTrace( 0, me, " FileSizes = %08lx\n", FileSizes ); // // Make a local copy of the new file size and section size. // NewSectionSize = FileSizes->AllocationSize; NewFileSize = FileSizes->FileSize; NewValidDataLength = FileSizes->ValidDataLength; // // Serialize Creation/Deletion of all Shared CacheMaps // CcAcquireMasterLock( &OldIrql ); // // Get pointer to SharedCacheMap via File Object. // SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; // // If the file is not cached, just get out. // if ((SharedCacheMap == NULL) || (SharedCacheMap->Section == NULL)) { CcReleaseMasterLock( OldIrql ); // // Let's try to purge the file incase this is a truncate. In the // vast majority of cases when there is no shared cache map, there // is no data section either, so this call will eventually be // no-oped in Mm. // // // First flush the first page we are keeping, if it has data, before // we throw it away. // if (NewFileSize.LowPart & (PAGE_SIZE - 1)) { MmFlushSection( FileObject->SectionObjectPointer, &NewFileSize, 1, &IoStatus, FALSE ); } CcPurgeCacheSection( FileObject->SectionObjectPointer, &NewFileSize, 0, FALSE ); DebugTrace(-1, me, "CcSetFileSizes -> VOID\n", 0 ); return; } // // Make call a Noop if file is not mapped, or section already big enough. // if ( NewSectionSize.QuadPart > SharedCacheMap->SectionSize.QuadPart ) { // // Increment open count to make sure the SharedCacheMap stays around, // then release the spinlock so that we can call Mm. // CcIncrementOpenCount( SharedCacheMap, '1fSS' ); CcReleaseMasterLock( OldIrql ); // // Round new section size to pages. // NewSectionSize.QuadPart = NewSectionSize.QuadPart + (LONGLONG)(DEFAULT_EXTEND_MODULO - 1); NewSectionSize.LowPart &= ~(DEFAULT_EXTEND_MODULO - 1); // // Use try-finally to make sure we get the open count decremented. // try { // // Call MM to extend the section. // DebugTrace( 0, mm, "MmExtendSection:\n", 0 ); DebugTrace( 0, mm, " Section = %08lx\n", SharedCacheMap->Section ); DebugTrace2(0, mm, " Size = %08lx, %08lx\n", NewSectionSize.LowPart, NewSectionSize.HighPart ); Status = MmExtendSection( SharedCacheMap->Section, &NewSectionSize, TRUE ); if (!NT_SUCCESS(Status)) { DebugTrace( 0, 0, "Error from MmExtendSection, Status = %08lx\n", Status ); ExRaiseStatus( FsRtlNormalizeNtstatus( Status, STATUS_UNEXPECTED_MM_EXTEND_ERR )); } // // Extend the Vacb array. // CcExtendVacbArray( SharedCacheMap, NewSectionSize ); } finally { // // Serialize again to decrement the open count. // CcAcquireMasterLock( &OldIrql ); CcDecrementOpenCount( SharedCacheMap, '1fSF' ); if ((SharedCacheMap->OpenCount == 0) && !FlagOn(SharedCacheMap->Flags, WRITE_QUEUED) && (SharedCacheMap->DirtyPages == 0)) { // // Move to the dirty list. // RemoveEntryList( &SharedCacheMap->SharedCacheMapLinks ); InsertTailList( &CcDirtySharedCacheMapList.SharedCacheMapLinks, &SharedCacheMap->SharedCacheMapLinks ); // // Make sure the Lazy Writer will wake up, because we // want him to delete this SharedCacheMap. // LazyWriter.OtherWork = TRUE; if (!LazyWriter.ScanActive) { CcScheduleLazyWriteScan(); } } CcReleaseMasterLock( OldIrql ); } // // It is now very unlikely that we have any more work to do, but just // in case we reacquire the spinlock and check again if we are cached. // CcAcquireMasterLock( &OldIrql ); // // Get pointer to SharedCacheMap via File Object. // SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; // // If the file is not cached, just get out. // if (SharedCacheMap == NULL) { CcReleaseMasterLock( OldIrql ); DebugTrace(-1, me, "CcSetFileSizes -> VOID\n", 0 ); return; } } // // If we are shrinking either of these two sizes, then we must free the // active page, since it may be locked. // CcIncrementOpenCount( SharedCacheMap, '2fSS' ); try { if ( ( NewFileSize.QuadPart < SharedCacheMap->ValidDataGoal.QuadPart ) || ( NewFileSize.QuadPart < SharedCacheMap->FileSize.QuadPart )) { GetActiveVacbAtDpcLevel( SharedCacheMap, ActiveVacb, ActivePage, PageIsDirty ); if ((ActiveVacb != NULL) || (SharedCacheMap->NeedToZero != NULL)) { CcReleaseMasterLock( OldIrql ); CcFreeActiveVacb( SharedCacheMap, ActiveVacb, ActivePage, PageIsDirty ); // // Serialize again to reduce ValidDataLength. It cannot change // because the caller must have the file exclusive. // CcAcquireMasterLock( &OldIrql ); } } // // If the section did not grow, see if the file system supports ValidDataLength, // then update the valid data length in the file system. // if ( SharedCacheMap->ValidDataLength.QuadPart != MAXLONGLONG ) { if ( NewFileSize.QuadPart < SharedCacheMap->ValidDataLength.QuadPart ) { SharedCacheMap->ValidDataLength = NewFileSize; } // // Update our notion of ValidDataGoal (how far the file has been written // in the cache) with caller's ValidDataLength. (Our ValidDataLength controls // when we issue ValidDataLength callbacks.) *** For now play it safe by // only growing here, which is the historical problem at hand, as with // compressed and uncompressed stream caches. // if (NewValidDataLength.QuadPart > SharedCacheMap->ValidDataGoal.QuadPart) { SharedCacheMap->ValidDataGoal = NewValidDataLength; } } // // On truncate, be nice guys and actually purge away user data from // the cache. However, the PinAccess check is important to avoid deadlocks // in Ntfs. // // It is also important to check the Vacb Active count. The caller // must have the file exclusive, therefore, no one else can be actively // doing anything in the file. Normally the Active count will be zero // (like in a normal call from Set File Info), and we can go ahead and truncate. // However, if the active count is nonzero, chances are this very thread has // something pinned or mapped, and we will deadlock if we try to purge and // wait for the count to go zero. A rare case of this which deadlocked DaveC // on Christmas Day of 1992, is where Ntfs was trying to convert an attribute // from resident to nonresident - which is a good example of a case where the // purge was not needed. // if ( (NewFileSize.QuadPart < SharedCacheMap->FileSize.QuadPart ) && !FlagOn(SharedCacheMap->Flags, PIN_ACCESS) && (SharedCacheMap->VacbActiveCount == 0)) { // // Release the spinlock so that we can call Mm. // CcReleaseMasterLock( OldIrql ); // // If we are actually truncating to zero (a size which has particular // meaning to the Lazy Writer scan!), then we must reset the Mbcb if // there is one, so that we do not keep dirty pages around forever. // if ((NewFileSize.QuadPart == 0) && (SharedCacheMap->Mbcb != NULL)) { CcDeleteMbcb( SharedCacheMap ); } CcPurgeAndClearCacheSection( SharedCacheMap, &NewFileSize ); // // Serialize again to decrement the open count. // CcAcquireMasterLock( &OldIrql ); } } finally { // // We should only be raising without owning the spinlock. // if (AbnormalTermination()) { CcAcquireMasterLock( &OldIrql ); } CcDecrementOpenCount( SharedCacheMap, '2fSF' ); SharedCacheMap->FileSize = NewFileSize; if ((SharedCacheMap->OpenCount == 0) && !FlagOn(SharedCacheMap->Flags, WRITE_QUEUED) && (SharedCacheMap->DirtyPages == 0)) { // // Move to the dirty list. // RemoveEntryList( &SharedCacheMap->SharedCacheMapLinks ); InsertTailList( &CcDirtySharedCacheMapList.SharedCacheMapLinks, &SharedCacheMap->SharedCacheMapLinks ); // // Make sure the Lazy Writer will wake up, because we // want him to delete this SharedCacheMap. // LazyWriter.OtherWork = TRUE; if (!LazyWriter.ScanActive) { CcScheduleLazyWriteScan(); } } CcReleaseMasterLock( OldIrql ); } DebugTrace(-1, me, "CcSetFileSizes -> VOID\n", 0 ); return; }

NTKERNELAPI VOID CcSetLogHandleForFile (  IN PFILE_OBJECT  FileObject, IN PVOID  LogHandle, IN PFLUSH_TO_LSN  FlushToLsnRoutine )

Definition at line 92 of file logsup.c. References _SHARED_CACHE_MAP::FlushToLsnRoutine, and _SHARED_CACHE_MAP::LogHandle. : This routine may be called to instruct the Cache Manager to store the specified log handle with the shared cache map for a file, to support subsequent calls to the other routines in this module which effectively perform an associative search for files by log handle. Arguments: FileObject - File for which the log handle should be stored. LogHandle - Log Handle to store. FlushToLsnRoutine - A routine to call before flushing buffers for this file, to insure a log file is flushed to the most recent Lsn for any Bcb being flushed. Return Value: None. --*/ { PSHARED_CACHE_MAP SharedCacheMap; // // Get pointer to SharedCacheMap. // SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; // // Now set the log file handle and flush routine // SharedCacheMap->LogHandle = LogHandle; SharedCacheMap->FlushToLsnRoutine = FlushToLsnRoutine; }

NTKERNELAPI VOID CcSetReadAheadGranularity (  IN PFILE_OBJECT  FileObject, IN ULONG  Granularity )

Definition at line 1222 of file cachesub.c. References PPRIVATE_CACHE_MAP. Referenced by UdfCommonRead(). : This routine may be called to set the read ahead granularity used by the Cache Manager. The default is PAGE_SIZE. The number is decremented and stored as a mask. Arguments: FileObject - File Object for which granularity shall be set Granularity - new granularity, which must be an even power of 2 and >= PAGE_SIZE Return Value: None --*/ { ((PPRIVATE_CACHE_MAP)FileObject->PrivateCacheMap)->ReadAheadMask = Granularity - 1; }

NTKERNELAPI BOOLEAN CcUninitializeCacheMap (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER TruncateSize  OPTIONAL, IN PCACHE_UNINITIALIZE_EVENT UninitializeCompleteEvent  OPTIONAL )

Referenced by CcPurgeCacheSection(), UdfCommonCleanup(), and UdfDeleteInternalStream().

NTKERNELAPI 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 ); }

NTKERNELAPI 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 ); }

NTKERNELAPI VOID CcUnpinRepinnedBcb (  IN PVOID  Bcb, IN BOOLEAN  WriteThrough, OUT PIO_STATUS_BLOCK  IoStatus )

Definition at line 5143 of file cachesub.c. References ASSERT, CcDeferredWrites, CcPostDeferredWrites(), CcSetDirtyPinnedData(), CcUnpinFileData(), DebugTrace, DebugTrace2, ExAcquireResourceExclusive, FALSE, _SHARED_CACHE_MAP::FileObject, FlagOn, _SHARED_CACHE_MAP::Flags, me, MmFlushSection(), MmSetAddressRangeModified(), MODIFIED_WRITE_DISABLED, NULL, Resource, RetryError, _FILE_OBJECT::SectionObjectPointer, SET_CLEAN, TRUE, and UNPIN. : This routine may be called to Write a previously pinned buffer through to the file. It must have been preceded by a call to CcRepinBcb. As this routine must acquire the Bcb resource exclusive, the caller must be extremely careful to avoid deadlocks. Ideally the caller owns no resources at all when it calls this routine, or else the caller should guarantee that it has nothing else pinned in this same file. (The latter rule is the one used to avoid deadlocks in calls from CcCopyWrite and CcMdlWrite.) Arguments: Bcb - Pointer to a Bcb which was previously specified in a call to CcRepinBcb. WriteThrough - TRUE if the Bcb should be written through. IoStatus - Returns the I/O status for the operation. Return Value: None. --*/ { PSHARED_CACHE_MAP SharedCacheMap = ((PBCB)Bcb)->SharedCacheMap; DebugTrace(+1, me, "CcUnpinRepinnedBcb\n", 0 ); DebugTrace( 0, me, " Bcb = %08lx\n", Bcb ); DebugTrace( 0, me, " WriteThrough = %02lx\n", WriteThrough ); // // Set status to success for non write through case. // IoStatus->Status = STATUS_SUCCESS; if (WriteThrough) { // // Acquire Bcb exclusive to eliminate possible modifiers of the buffer, // since we are about to write its buffer. // if (FlagOn(SharedCacheMap->Flags, MODIFIED_WRITE_DISABLED)) { ExAcquireResourceExclusive( &((PBCB)Bcb)->Resource, TRUE ); } // // Now, there is a chance that the LazyWriter has already written // it, since the resource was free. We will only write it if it // is still dirty. // if (((PBCB)Bcb)->Dirty) { // // First we make sure that the dirty bit in the PFN database is set. // ASSERT( ((PBCB)Bcb)->BaseAddress != NULL ); MmSetAddressRangeModified( ((PBCB)Bcb)->BaseAddress, ((PBCB)Bcb)->ByteLength ); // // Now release the Bcb resource and set it clean. Note we do not check // here for errors, and just return the I/O status. Errors on writes // are rare to begin with. Nonetheless, our strategy is to rely on // one or more of the following (depending on the file system) to prevent // errors from getting to us. // // - Retries and/or other forms of error recovery in the disk driver // - Mirroring driver // - Hot fixing in the noncached path of the file system // // In the unexpected case that a write error does get through, we // report it to our caller, but go ahead and set the Bcb clean. There // seems to be no point in letting Bcbs (and pages in physical memory) // accumulate which can never go away because we get an unrecoverable I/O // error. // // // We specify TRUE here for ReadOnly so that we will keep the // resource during the flush. // CcUnpinFileData( (PBCB)Bcb, TRUE, SET_CLEAN ); // // Write it out. // MmFlushSection( ((PBCB)Bcb)->SharedCacheMap->FileObject->SectionObjectPointer, &((PBCB)Bcb)->FileOffset, ((PBCB)Bcb)->ByteLength, IoStatus, TRUE ); // // If we got verify required, we have to mark the buffer dirty again // so we will try again later. // if (RetryError(IoStatus->Status)) { CcSetDirtyPinnedData( (PBCB)Bcb, NULL ); } // // Now remove the final pin count now that we have set it clean. // CcUnpinFileData( (PBCB)Bcb, FALSE, UNPIN ); // // See if there is any deferred writes we can post. // if (!IsListEmpty(&CcDeferredWrites)) { CcPostDeferredWrites(); } } else { // // Lazy Writer got there first, just free the resource and unpin. // CcUnpinFileData( (PBCB)Bcb, FALSE, UNPIN ); } DebugTrace2(0, me, " <IoStatus = %08lx, %08lx\n", IoStatus->Status, IoStatus->Information ); } // // Non-WriteThrough case // else { CcUnpinFileData( (PBCB)Bcb, TRUE, UNPIN ); // // Set status to success for non write through case. // IoStatus->Status = STATUS_SUCCESS; } DebugTrace(-1, me, "CcUnpinRepinnedBcb -> VOID\n", 0 ); }

NTSTATUS CcWaitForCurrentLazyWriterActivity (   )

Definition at line 158 of file lazyrite.c. References CcAcquireMasterLock, CcAllocateWorkQueueEntry, CcPostTickWorkQueue, CcReleaseMasterLock, CcScheduleLazyWriteScan(), Event(), EventSet, Executive, FALSE, _WORK_QUEUE_ENTRY::Function, KeInitializeEvent, KernelMode, KeWaitForSingleObject(), LazyWriter, NULL, _LAZY_WRITER::OtherWork, _WORK_QUEUE_ENTRY::Parameters, _LAZY_WRITER::ScanActive, TRUE, and _WORK_QUEUE_ENTRY::WorkQueueLinks. Referenced by UdfLockVolumeInternal(). : This routine allows a thread to receive notification when the current tick of lazy writer work has completed. It must not be called within a lazy writer workitem! The caller must not be holding synchronization that could block a Cc workitem! In particular, this lets a caller insure that all avaliable lazy closes at the time of the call have completed. Arguments: None. Return Value: Final result of the wait. --*/ { KIRQL OldIrql; KEVENT Event; PWORK_QUEUE_ENTRY WorkQueueEntry; WorkQueueEntry = CcAllocateWorkQueueEntry(); if (WorkQueueEntry == NULL) { return STATUS_INSUFFICIENT_RESOURCES; } WorkQueueEntry->Function = (UCHAR)EventSet; KeInitializeEvent( &Event, NotificationEvent, FALSE ); WorkQueueEntry->Parameters.Event.Event = &Event; // // Add this to the post-tick work queue and wake the lazy writer for it. // The lazy writer will add this to the end of the next batch of work // he issues. // CcAcquireMasterLock( &OldIrql ); InsertTailList( &CcPostTickWorkQueue, &WorkQueueEntry->WorkQueueLinks ); LazyWriter.OtherWork = TRUE; if (!LazyWriter.ScanActive) { CcScheduleLazyWriteScan(); } CcReleaseMasterLock( OldIrql ); return KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, NULL ); }

NTKERNELAPI BOOLEAN CcZeroData (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  StartOffset, IN PLARGE_INTEGER  EndOffset, IN BOOLEAN  Wait )

Definition at line 2952 of file fssup.c. References ASSERT, _MDL::ByteCount, CcAggressiveZeroCount, CcAggressiveZeroThreshold, CcPinFileData(), CcSetDirtyPinnedData(), CcUnpinFileData(), COMPUTE_PAGES_SPANNED, DebugTrace, Event(), ExAllocatePoolWithTag, Executive, ExFreePool(), ExRaiseStatus(), FALSE, FlagOn, FO_WRITE_THROUGH, IoAllocateMdl(), IoFreeMdl(), IoGetRelatedDeviceObject(), IoReadAccess, IoSynchronousPageWrite(), KeInitializeEvent, KernelMode, KeSweepDcache(), KeWaitForSingleObject(), LowPagePriority, _MDL::MappedSystemVa, MAX_ZERO_TRANSFER, MAX_ZEROS_IN_CACHE, MDL_PAGES_LOCKED, MDL_SOURCE_IS_NONPAGED_POOL, _MDL::MdlFlags, me, MIN_ZERO_TRANSFER, MmAvailablePages, MmBuildMdlForNonPagedPool(), MmDisablePageFaultClustering, MmEnablePageFaultClustering, MmGetMdlPfnArray, MmGetSystemAddressForMdl, MmGetSystemAddressForMdlSafe, MmProbeAndLockPages(), MmSetAddressRangeModified(), MmUnlockPages(), MmUnmapLockedPages(), NonPagedPoolCacheAligned, NT_SUCCESS, NTSTATUS(), NULL, PAGE_SIZE, _DEVICE_OBJECT::SectorSize, Status, TRUE, try_return, and UNPIN. Referenced by FsRtlCopyWrite(), and FsRtlPrepareMdlWriteDev(). : This routine attempts to zero the specified file data and deliver the correct I/O status. If the caller does not want to block (such as for disk I/O), then Wait should be supplied as FALSE. If Wait was supplied as FALSE and it is currently impossible to zero all of the requested data without blocking, then this routine will return FALSE. However, if the required space is immediately accessible in the cache and no blocking is required, this routine zeros the data and returns TRUE. If the caller supplies Wait as TRUE, then this routine is guaranteed to zero the data and return TRUE. If the correct space is immediately accessible in the cache, then no blocking will occur. Otherwise, the necessary work will be initiated to read and/or free cache data, and the caller will be blocked until the data can be received. File system Fsd's should typically supply Wait = TRUE if they are processing a synchronous I/O requests, or Wait = FALSE if they are processing an asynchronous request. File system threads should supply Wait = TRUE. IMPORTANT NOTE: File systems which call this routine must be prepared to handle a special form of a write call where the Mdl is already supplied. Namely, if Irp->MdlAddress is supplied, the file system must check the low order bit of Irp->MdlAddress->ByteOffset. If it is set, that means that the Irp was generated in this routine and the file system must do two things: Decrement Irp->MdlAddress->ByteOffset and Irp->UserBuffer Clear Irp->MdlAddress immediately prior to completing the request, as this routine expects to reuse the Mdl and ultimately deallocate the Mdl itself. Arguments: FileObject - pointer to the FileObject for which a range of bytes is to be zeroed. This FileObject may either be for a cached file or a noncached file. If the file is not cached, then WriteThrough must be TRUE and StartOffset and EndOffset must be on sector boundaries. StartOffset - Start offset in file to be zeroed. EndOffset - End offset in file to be zeroed. Wait - FALSE if caller may not block, TRUE otherwise (see description above) Return Value: FALSE - if Wait was supplied as FALSE and the data was not zeroed. TRUE - if the data has been zeroed. Raises: STATUS_INSUFFICIENT_RESOURCES - If a pool allocation failure occurs. This can only occur if Wait was specified as TRUE. (If Wait is specified as FALSE, and an allocation failure occurs, this routine simply returns FALSE.) --*/ { PSHARED_CACHE_MAP SharedCacheMap; PVOID CacheBuffer; LARGE_INTEGER FOffset; LARGE_INTEGER ToGo; ULONG ZeroBytes, ZeroTransfer; ULONG SectorMask; ULONG i; BOOLEAN WriteThrough; BOOLEAN AggressiveZero = FALSE; ULONG SavedState = 0; ULONG MaxZerosInCache = MAX_ZEROS_IN_CACHE; ULONG NumberOfColors = 1; PBCB Bcb = NULL; PCHAR Zeros = NULL; PMDL ZeroMdl = NULL; ULONG MaxBytesMappedInMdl = 0; BOOLEAN Result = TRUE; PPFN_NUMBER Page; ULONG SavedByteCount; LARGE_INTEGER SizeLeft; DebugTrace(+1, me, "CcZeroData\n", 0 ); WriteThrough = (BOOLEAN)(((FileObject->Flags & FO_WRITE_THROUGH) != 0) || (FileObject->PrivateCacheMap == NULL)); // // If the caller specified Wait, but the FileObject is WriteThrough, // then we need to just get out. // if (WriteThrough && !Wait) { DebugTrace(-1, me, "CcZeroData->FALSE (WriteThrough && !Wait)\n", 0 ); return FALSE; } SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; SectorMask = IoGetRelatedDeviceObject(FileObject)->SectorSize - 1; FOffset = *StartOffset; // // Calculate how much to zero this time. // ToGo.QuadPart = EndOffset->QuadPart - FOffset.QuadPart; // // This magic number is what the fastpaths throttle on, and they will present // non-sector aligned zeroing requests. As long as we will always handle them // on the cached path, we are OK. // // If we will not make the cached path, the request must be aligned. // ASSERT( ToGo.QuadPart <= 0x2000 || ((ToGo.LowPart & SectorMask) == 0 && (FOffset.LowPart & SectorMask) == 0)); // // We will only do zeroing in the cache if the caller is using a // cached file object, and did not specify WriteThrough. We are // willing to zero some data in the cache if our total is not too // much, or there is sufficient available pages. // if (((ToGo.QuadPart <= 0x2000) || (MmAvailablePages >= ((MAX_ZEROS_IN_CACHE / PAGE_SIZE) * 4))) && !WriteThrough) { try { while (MaxZerosInCache != 0) { ULONG ReceivedLength; LARGE_INTEGER BeyondLastByte; if ( ToGo.QuadPart > (LONGLONG)MaxZerosInCache ) { // // If Wait == FALSE, then there is no point in getting started, // because we would have to start all over again zeroing with // Wait == TRUE, since we would fall out of this loop and // start synchronously writing pages to disk. // if (!Wait) { DebugTrace(-1, me, "CcZeroData -> FALSE\n", 0 ); try_return( Result = FALSE ); } } else { MaxZerosInCache = ToGo.LowPart; } // // Call local routine to Map or Access the file data, then zero the data, // then call another local routine to free the data. If we cannot map // the data because of a Wait condition, return FALSE. // // Note that this call may result in an exception, however, if it // does no Bcb is returned and this routine has absolutely no // cleanup to perform. Therefore, we do not have a try-finally // and we allow the possibility that we will simply be unwound // without notice. // if (!CcPinFileData( FileObject, &FOffset, MaxZerosInCache, FALSE, TRUE, Wait, &Bcb, &CacheBuffer, &BeyondLastByte )) { DebugTrace(-1, me, "CcZeroData -> FALSE\n", 0 ); try_return( Result = FALSE ); } // // Calculate how much data is described by Bcb starting at our desired // file offset. If it is more than we need, we will zero the whole thing // anyway. // ReceivedLength = (ULONG)(BeyondLastByte.QuadPart - FOffset.QuadPart ); // // Now attempt to allocate an Mdl to describe the mapped data. // ZeroMdl = IoAllocateMdl( CacheBuffer, ReceivedLength, FALSE, FALSE, NULL ); if (ZeroMdl == NULL) { ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } // // It is necessary to probe and lock the pages, or else // the pages may not still be in memory when we do the // MmSetAddressRangeModified for the dirty Bcb. // MmDisablePageFaultClustering(&SavedState); MmProbeAndLockPages( ZeroMdl, KernelMode, IoReadAccess ); MmEnablePageFaultClustering(SavedState); SavedState = 0; // // Assume we did not get all the data we wanted, and set FOffset // to the end of the returned data, and advance buffer pointer. // FOffset = BeyondLastByte; // // Figure out how many bytes we are allowed to zero in the cache. // Note it is possible we have zeroed a little more than our maximum, // because we hit an existing Bcb that extended beyond the range. // if (MaxZerosInCache <= ReceivedLength) { MaxZerosInCache = 0; } else { MaxZerosInCache -= ReceivedLength; } // // Now set the Bcb dirty. We have to explicitly set the address // range modified here, because that work otherwise gets deferred // to the Lazy Writer. // MmSetAddressRangeModified( CacheBuffer, ReceivedLength ); CcSetDirtyPinnedData( Bcb, NULL ); // // Unmap the data now // CcUnpinFileData( Bcb, FALSE, UNPIN ); Bcb = NULL; // // Unlock and free the Mdl (we only loop back if we crossed // a 256KB boundary. // MmUnlockPages( ZeroMdl ); IoFreeMdl( ZeroMdl ); ZeroMdl = NULL; } try_exit: NOTHING; } finally { if (SavedState != 0) { MmEnablePageFaultClustering(SavedState); } // // Clean up only necessary in abnormal termination. // if (Bcb != NULL) { CcUnpinFileData( Bcb, FALSE, UNPIN ); } // // Since the last thing in the above loop which can // fail is the MmProbeAndLockPages, we only need to // free the Mdl here. // if (ZeroMdl != NULL) { IoFreeMdl( ZeroMdl ); } } // // If hit a wait condition above, return it now. // if (!Result) { return FALSE; } // // If we finished, get out nbow. // if ( FOffset.QuadPart >= EndOffset->QuadPart ) { return TRUE; } } // // We either get here because we decided above not to zero anything in // the cache directly, or else we zeroed up to our maximum and still // have some left to zero direct to the file on disk. In either case, // we will now zero from FOffset to *EndOffset, and then flush this // range in case the file is cached/mapped, and there are modified // changes in memory. // // // Round FOffset and EndOffset up to sector boundaries, since // we will be doing disk I/O, and calculate size left. // ASSERT( (FOffset.LowPart & SectorMask) == 0 ); FOffset.QuadPart += (LONGLONG)SectorMask; FOffset.LowPart &= ~SectorMask; SizeLeft.QuadPart = EndOffset->QuadPart + (LONGLONG)SectorMask; SizeLeft.LowPart &= ~SectorMask; SizeLeft.QuadPart -= FOffset.QuadPart; ASSERT( (FOffset.LowPart & SectorMask) == 0 ); ASSERT( (SizeLeft.LowPart & SectorMask) == 0 ); if (SizeLeft.QuadPart == 0) { return TRUE; } // // try-finally to guarantee cleanup. // try { // // Allocate a page to hold the zeros we will write, and // zero it. // ZeroBytes = NumberOfColors * PAGE_SIZE; if (SizeLeft.HighPart == 0 && SizeLeft.LowPart < ZeroBytes) { ZeroBytes = SizeLeft.LowPart; } Zeros = (PCHAR)ExAllocatePoolWithTag( NonPagedPoolCacheAligned, ZeroBytes, 'eZcC' ); if (Zeros != NULL) { // // Allocate and initialize an Mdl to describe the zeros // we need to transfer. Allocate to cover the maximum // size required, and we will use and reuse it in the // loop below, initialized correctly. // if (SizeLeft.HighPart == 0 && SizeLeft.LowPart < MAX_ZERO_TRANSFER) { ZeroTransfer = SizeLeft.LowPart; } else { // // See how aggressive we can afford to be. // if (InterlockedIncrement( &CcAggressiveZeroCount ) <= CcAggressiveZeroThreshold) { AggressiveZero = TRUE; ZeroTransfer = MAX_ZERO_TRANSFER; } else { InterlockedDecrement( &CcAggressiveZeroCount ); ZeroTransfer = MIN_ZERO_TRANSFER; } } // // Since the maximum zero may start at a very aggresive level, fall back // until we really have to give up. Since filter drivers, filesystems and // even storage drivers may need to map this Mdl, we have to pre-map it // into system space so that we know enough PTEs are avaliable. We also // need to throttle our consumption of virtual addresses based on the size // of the system and the number of parallel instances of this work outstanding. // This may be a bit of overkill, but since running out of PTEs is a fatal // event for the rest of the system, try to help out while still being fast. // while (TRUE) { // // Spin down trying to get an MDL which can describe our operation. // while (TRUE) { ZeroMdl = IoAllocateMdl( Zeros, ZeroTransfer, FALSE, FALSE, NULL ); // // Throttle ourselves to what we've physically allocated. Note that // we could have started with an odd multiple of this number. If we // tried for exactly that size and failed, we're toast. // if (ZeroMdl || ZeroTransfer == ZeroBytes) { break; } Fall_Back: // // Fallback by half and round down to a sector multiple. // ZeroTransfer /= 2; ZeroTransfer &= ~SectorMask; if (ZeroTransfer < ZeroBytes) { ZeroTransfer = ZeroBytes; } ASSERT( (ZeroTransfer & SectorMask) == 0 && ZeroTransfer != 0); } if (ZeroMdl == NULL) { ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } // // If we have throttled all the way down, stop and just build a // simple MDL describing our previous allocation. // if (ZeroTransfer == ZeroBytes) { MmBuildMdlForNonPagedPool( ZeroMdl ); break; } // // Now we will temporarily lock the allocated pages // only, and then replicate the page frame numbers through // the entire Mdl to keep writing the same pages of zeros. // // It would be nice if Mm exported a way for us to not have // to pull the Mdl apart and rebuild it ourselves, but this // is so bizzare a purpose as to be tolerable. // SavedByteCount = ZeroMdl->ByteCount; ZeroMdl->ByteCount = ZeroBytes; MmBuildMdlForNonPagedPool( ZeroMdl ); ZeroMdl->MdlFlags &= ~MDL_SOURCE_IS_NONPAGED_POOL; ZeroMdl->MdlFlags |= MDL_PAGES_LOCKED; ZeroMdl->MappedSystemVa = NULL; ZeroMdl->ByteCount = SavedByteCount; Page = MmGetMdlPfnArray( ZeroMdl ); for (i = NumberOfColors; i < (COMPUTE_PAGES_SPANNED( 0, SavedByteCount )); i++) { *(Page + i) = *(Page + i - NumberOfColors); } if (MmGetSystemAddressForMdlSafe( ZeroMdl, LowPagePriority ) == NULL) { // // Blow away this Mdl and trim for the retry. Since it didn't // get mapped, there is nothing fancy to do. // IoFreeMdl( ZeroMdl ); goto Fall_Back; } break; } // // We failed to allocate the space we wanted, so we will go to // half of a page and limp along. // } else { // // Of course, if we have a device which has large sectors, that defines // the lower limit of our attempt. // if (IoGetRelatedDeviceObject(FileObject)->SectorSize < PAGE_SIZE / 2) { ZeroBytes = PAGE_SIZE / 2; Zeros = (PCHAR)ExAllocatePoolWithTag( NonPagedPoolCacheAligned, ZeroBytes, 'eZcC' ); } // // If we cannot get even that much, then let's write a sector at a time. // if (Zeros == NULL) { ZeroBytes = IoGetRelatedDeviceObject(FileObject)->SectorSize; Zeros = (PCHAR)ExAllocatePoolWithTag( NonPagedPoolCacheAligned, ZeroBytes, 'eZcC' ); // // If we cannot get even the minimum, we have to give up. // if (Zeros == NULL) { ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } } // // Allocate and initialize an Mdl to describe the zeros // we need to transfer. Allocate to cover the maximum // size required, and we will use and reuse it in the // loop below, initialized correctly. // ZeroTransfer = ZeroBytes; ZeroMdl = IoAllocateMdl( Zeros, ZeroBytes, FALSE, FALSE, NULL ); ASSERT( (ZeroTransfer & SectorMask) == 0 ); if (ZeroMdl == NULL) { ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES ); } // // Now we will lock and map the allocated pages. // MmBuildMdlForNonPagedPool( ZeroMdl ); ASSERT( ZeroMdl->MappedSystemVa == Zeros ); } #ifdef MIPS #ifdef MIPS_PREFILL RtlFillMemory( Zeros, ZeroBytes, 0xDD ); KeSweepDcache( TRUE ); #endif #endif // // Zero the buffer now. // RtlZeroMemory( Zeros, ZeroBytes ); // // We have a mapped and zeroed range back by an MDL to use. Note the // size we have for cleanup, since we will possibly wind this down // over the operation. // ASSERT( MmGetSystemAddressForMdl(ZeroMdl) ); MaxBytesMappedInMdl = ZeroMdl->ByteCount; // // Now loop to write buffers full of zeros through to the file // until we reach the starting Vbn for the transfer. // ASSERT( ZeroTransfer != 0 && (ZeroTransfer & SectorMask) == 0 && (SizeLeft.LowPart & SectorMask) == 0 ); while ( SizeLeft.QuadPart != 0 ) { IO_STATUS_BLOCK IoStatus; NTSTATUS Status; KEVENT Event; // // See if we really need to write that many zeros, and // trim the size back if not. // if ( (LONGLONG)ZeroTransfer > SizeLeft.QuadPart ) { ZeroTransfer = SizeLeft.LowPart; } // // (Re)initialize the kernel event to FALSE. // KeInitializeEvent( &Event, NotificationEvent, FALSE ); // // Initiate and wait for the synchronous transfer. // ZeroMdl->ByteCount = ZeroTransfer; Status = IoSynchronousPageWrite( FileObject, ZeroMdl, &FOffset, &Event, &IoStatus ); // // If pending is returned (which is a successful status), // we must wait for the request to complete. // if (Status == STATUS_PENDING) { KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, (PLARGE_INTEGER)NULL); } // // If we got an error back in Status, then the Iosb // was not written, so we will just copy the status // there, then test the final status after that. // if (!NT_SUCCESS(Status)) { ExRaiseStatus( Status ); } if (!NT_SUCCESS(IoStatus.Status)) { ExRaiseStatus( IoStatus.Status ); } // // If we succeeded, then update where we are at by how much // we wrote, and loop back to see if there is more. // FOffset.QuadPart = FOffset.QuadPart + (LONGLONG)ZeroTransfer; SizeLeft.QuadPart = SizeLeft.QuadPart - (LONGLONG)ZeroTransfer; } } finally{ // // Clean up anything from zeroing pages on a noncached // write. // if (ZeroMdl != NULL) { if ((MaxBytesMappedInMdl != 0) && !FlagOn(ZeroMdl->MdlFlags, MDL_SOURCE_IS_NONPAGED_POOL)) { ZeroMdl->ByteCount = MaxBytesMappedInMdl; MmUnmapLockedPages (ZeroMdl->MappedSystemVa, ZeroMdl); } IoFreeMdl( ZeroMdl ); } if (AggressiveZero) { InterlockedDecrement( &CcAggressiveZeroCount ); } if (Zeros != NULL) { ExFreePool( Zeros ); } DebugTrace(-1, me, "CcZeroData -> TRUE\n", 0 ); } return TRUE; }

NTKERNELAPI VOID CcZeroEndOfLastPage (  IN PFILE_OBJECT  FileObject  )

Definition at line 2804 of file fssup.c. References _SHARED_CACHE_MAP::ActiveVacb, ASSERT, CcAcquireMasterLock, CcDecrementOpenCount, CcDirtySharedCacheMapList, CcFlushCache(), CcFreeActiveVacb(), CcIncrementOpenCount, CcPurgeCacheSection(), CcReleaseMasterLock, CcScheduleLazyWriteScan(), _SHARED_CACHE_MAP::DirtyPages, FALSE, FlagOn, _SHARED_CACHE_MAP::Flags, FSRTL_FLAG2_PURGE_WHEN_MAPPED, FSRTL_FLAG_ADVANCED_HEADER, FSRTL_FLAG_USER_MAPPED_FILE, FsRtlAcquireFileExclusive(), FsRtlReleaseFile(), GetActiveVacbAtDpcLevel, LazyWriter, _SHARED_CACHE_MAP::NeedToZero, NULL, _SHARED_CACHE_MAP::OpenCount, _LAZY_WRITER::OtherWork, _LAZY_WRITER::ScanActive, SetFlag, _SHARED_CACHE_MAP_LIST_CURSOR::SharedCacheMapLinks, _SHARED_CACHE_MAP::SharedCacheMapLinks, TRUE, and WRITE_QUEUED. Referenced by MiCreateImageFileMap(), and NtCreateSection(). : This routine is only called by Mm before mapping a user view to a section. If there is an uninitialized page at the end of the file, we zero it by freeing that page. Parameters: FileObject - File object for section to be mapped Return Value: None --*/ { PSHARED_CACHE_MAP SharedCacheMap; ULONG ActivePage; ULONG PageIsDirty; KIRQL OldIrql; PVOID NeedToZero = NULL; PVACB ActiveVacb = NULL; IO_STATUS_BLOCK Iosb; BOOLEAN PurgeResult; // // See if we have an active Vacb, that we need to free. // FsRtlAcquireFileExclusive( FileObject ); CcAcquireMasterLock( &OldIrql ); SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; if (SharedCacheMap != NULL) { // // See if there is an active vacb. // if ((SharedCacheMap->ActiveVacb != NULL) || ((NeedToZero = SharedCacheMap->NeedToZero) != NULL)) { CcIncrementOpenCount( SharedCacheMap, 'peZS' ); GetActiveVacbAtDpcLevel( SharedCacheMap, ActiveVacb, ActivePage, PageIsDirty ); } } CcReleaseMasterLock( OldIrql ); // // Remember in FsRtl header is there is a user section. // If this is an advanced header then also acquire the mutex to access // this field. // if (FlagOn( ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->Flags, FSRTL_FLAG_ADVANCED_HEADER )) { ExAcquireFastMutex( ((PFSRTL_ADVANCED_FCB_HEADER)FileObject->FsContext)->FastMutex ); SetFlag( ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->Flags, FSRTL_FLAG_USER_MAPPED_FILE ); ExReleaseFastMutex( ((PFSRTL_ADVANCED_FCB_HEADER)FileObject->FsContext)->FastMutex ); } else { SetFlag( ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->Flags, FSRTL_FLAG_USER_MAPPED_FILE ); } // // Free the active vacb now so we don't deadlock if we have to purge // if ((ActiveVacb != NULL) || (NeedToZero != NULL)) { CcFreeActiveVacb( SharedCacheMap, ActiveVacb, ActivePage, PageIsDirty ); } if (FlagOn( ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->Flags2, FSRTL_FLAG2_PURGE_WHEN_MAPPED )) { if (FileObject->SectionObjectPointer->SharedCacheMap) { ASSERT( ((PSHARED_CACHE_MAP)(FileObject->SectionObjectPointer->SharedCacheMap))->VacbActiveCount == 0 ); } CcFlushCache( FileObject->SectionObjectPointer, NULL, 0, &Iosb ); PurgeResult = CcPurgeCacheSection( FileObject->SectionObjectPointer, NULL, 0, FALSE ); if (FileObject->SectionObjectPointer->SharedCacheMap) { ASSERT( ((PSHARED_CACHE_MAP)(FileObject->SectionObjectPointer->SharedCacheMap))->VacbActiveCount == 0 ); } } FsRtlReleaseFile( FileObject ); // // If the file is cached and we have a Vacb to free, we need to // use the lazy writer callback to synchronize so no one will be // extending valid data. // if ((ActiveVacb != NULL) || (NeedToZero != NULL)) { // // Serialize again to decrement the open count. // CcAcquireMasterLock( &OldIrql ); CcDecrementOpenCount( SharedCacheMap, 'peZF' ); if ((SharedCacheMap->OpenCount == 0) && !FlagOn(SharedCacheMap->Flags, WRITE_QUEUED) && (SharedCacheMap->DirtyPages == 0)) { // // Move to the dirty list. // RemoveEntryList( &SharedCacheMap->SharedCacheMapLinks ); InsertTailList( &CcDirtySharedCacheMapList.SharedCacheMapLinks, &SharedCacheMap->SharedCacheMapLinks ); // // Make sure the Lazy Writer will wake up, because we // want him to delete this SharedCacheMap. // LazyWriter.OtherWork = TRUE; if (!LazyWriter.ScanActive) { CcScheduleLazyWriteScan(); } } CcReleaseMasterLock( OldIrql ); } }

---

Variable Documentation

ULONG CcCopyReadNoWait

Definition at line 211 of file cache.h. Referenced by CcCopyRead(), and NtQuerySystemInformation().

ULONG CcCopyReadNoWaitMiss

Definition at line 213 of file cache.h. Referenced by CcCopyRead(), and NtQuerySystemInformation().

ULONG CcCopyReadWait

Definition at line 212 of file cache.h. Referenced by CcCopyRead(), CcFastCopyRead(), and NtQuerySystemInformation().

ULONG CcCopyReadWaitMiss

Definition at line 214 of file cache.h. Referenced by CcCopyRead(), CcFastCopyRead(), and NtQuerySystemInformation().

ULONG CcDataFlushes

Definition at line 225 of file cache.h. Referenced by IoSynchronousPageWrite(), and NtQuerySystemInformation().

ULONG CcDataPages

Definition at line 226 of file cache.h. Referenced by IoSynchronousPageWrite(), and NtQuerySystemInformation().

ULONG CcFastMdlReadNotPossible

Definition at line 197 of file cache.h. Referenced by FsRtlMdlReadDev(), and NtQuerySystemInformation().

ULONG CcFastMdlReadNoWait

Definition at line 194 of file cache.h. Referenced by NtQuerySystemInformation().

ULONG CcFastMdlReadResourceMiss

Definition at line 196 of file cache.h. Referenced by NtQuerySystemInformation().

ULONG CcFastMdlReadWait

Definition at line 195 of file cache.h. Referenced by FsRtlMdlReadDev(), and NtQuerySystemInformation().

ULONG CcFastReadNotPossible

Definition at line 192 of file cache.h. Referenced by FsRtlCopyRead(), and NtQuerySystemInformation().

ULONG CcFastReadNoWait

Definition at line 189 of file cache.h. Referenced by FsRtlCopyRead(), and NtQuerySystemInformation().

ULONG CcFastReadResourceMiss

Definition at line 191 of file cache.h. Referenced by FsRtlCopyRead(), and NtQuerySystemInformation().

ULONG CcFastReadWait

Definition at line 190 of file cache.h. Referenced by FsRtlCopyRead(), and NtQuerySystemInformation().

ULONG CcLazyWriteIos

Definition at line 223 of file cache.h. Referenced by CcFlushCache(), and NtQuerySystemInformation().

ULONG CcLazyWritePages

Definition at line 224 of file cache.h. Referenced by CcFlushCache(), and NtQuerySystemInformation().

ULONG CcMapDataNoWait

Definition at line 199 of file cache.h. Referenced by CcMapData(), and NtQuerySystemInformation().

ULONG CcMapDataNoWaitMiss

Definition at line 201 of file cache.h. Referenced by CcMapData(), and NtQuerySystemInformation().

ULONG CcMapDataWait

Definition at line 200 of file cache.h. Referenced by CcMapData(), and NtQuerySystemInformation().

ULONG CcMapDataWaitMiss

Definition at line 202 of file cache.h. Referenced by CcMapData(), and NtQuerySystemInformation().

ULONG CcMdlReadNoWait

Definition at line 216 of file cache.h. Referenced by NtQuerySystemInformation().

ULONG CcMdlReadNoWaitMiss

Definition at line 218 of file cache.h. Referenced by NtQuerySystemInformation().

ULONG CcMdlReadWait

Definition at line 217 of file cache.h. Referenced by CcMdlRead(), and NtQuerySystemInformation().

ULONG CcMdlReadWaitMiss

Definition at line 219 of file cache.h. Referenced by CcMdlRead(), and NtQuerySystemInformation().

PULONG CcMissCounter

Definition at line 228 of file cache.h. Referenced by CcCopyRead(), CcFastCopyRead(), CcMapData(), CcMdlRead(), CcPerformReadAhead(), CcPinRead(), CcPreparePinWrite(), and IoPageRead().

ULONG CcPinMappedDataCount

Definition at line 204 of file cache.h. Referenced by CcPinMappedData(), and NtQuerySystemInformation().

ULONG CcPinReadNoWait

Definition at line 206 of file cache.h. Referenced by CcPinRead(), and NtQuerySystemInformation().

ULONG CcPinReadNoWaitMiss

Definition at line 208 of file cache.h. Referenced by CcPinRead(), and NtQuerySystemInformation().

ULONG CcPinReadWait

Definition at line 207 of file cache.h. Referenced by CcPinRead(), and NtQuerySystemInformation().

ULONG CcPinReadWaitMiss

Definition at line 209 of file cache.h. Referenced by CcPinRead(), and NtQuerySystemInformation().

ULONG CcReadAheadIos

Definition at line 221 of file cache.h. Referenced by CcPerformReadAhead(), and NtQuerySystemInformation().

ULONG CcThrowAway

Definition at line 183 of file cache.h. Referenced by CcCopyRead(), CcFastCopyRead(), CcMapData(), CcMdlRead(), CcPerformReadAhead(), CcPinRead(), and CcPreparePinWrite().

---