fssup.c File Reference

#include <ntoskrnl.h>
#include "newcc.h"
#include "section/newmm.h"
#include <debug.h>

Include dependency graph for fssup.c:

Go to the source code of this file.

Classes
struct	_NOCC_PRIVATE_CACHE_MAP

Macros
#define	NDEBUG

Typedefs
typedef struct _NOCC_PRIVATE_CACHE_MAP	NOCC_PRIVATE_CACHE_MAP
typedef struct _NOCC_PRIVATE_CACHE_MAP *	PNOCC_PRIVATE_CACHE_MAP

Functions
VOID NTAPI	CcpUnmapThread (PVOID Unused)
VOID NTAPI	CcpLazyWriteThread (PVOID Unused)
BOOLEAN NTAPI	CcInitializeCacheManager (VOID)
VOID NTAPI	CcPfInitializePrefetcher (VOID)
BOOLEAN NTAPI	CcpAcquireFileLock (PNOCC_CACHE_MAP Map)
VOID NTAPI	CcpReleaseFileLock (PNOCC_CACHE_MAP Map)
PFILE_OBJECT	CcpFindOtherStreamFileObject (PFILE_OBJECT FileObject)
VOID NTAPI	CcInitializeCacheMap (IN PFILE_OBJECT FileObject, IN PCC_FILE_SIZES FileSizes, IN BOOLEAN PinAccess, IN PCACHE_MANAGER_CALLBACKS Callbacks, IN PVOID LazyWriteContext)
ULONG NTAPI	CcpCountCacheSections (IN PNOCC_CACHE_MAP Map)
BOOLEAN NTAPI	CcUninitializeCacheMap (IN PFILE_OBJECT FileObject, IN OPTIONAL PLARGE_INTEGER TruncateSize, IN OPTIONAL PCACHE_UNINITIALIZE_EVENT UninitializeEvent)
VOID NTAPI	CcSetFileSizes (IN PFILE_OBJECT FileObject, IN PCC_FILE_SIZES FileSizes)
BOOLEAN NTAPI	CcGetFileSizes (IN PFILE_OBJECT FileObject, IN PCC_FILE_SIZES FileSizes)
BOOLEAN NTAPI	CcPurgeCacheSection (IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN OPTIONAL PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN UninitializeCacheMaps)
VOID NTAPI	CcSetDirtyPageThreshold (IN PFILE_OBJECT FileObject, IN ULONG DirtyPageThreshold)
BOOLEAN NTAPI	CcZeroData (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER StartOffset, IN PLARGE_INTEGER EndOffset, IN BOOLEAN Wait)
PFILE_OBJECT NTAPI	CcGetFileObjectFromSectionPtrs (IN PSECTION_OBJECT_POINTERS SectionObjectPointer)
PFILE_OBJECT NTAPI	CcGetFileObjectFromBcb (PVOID Bcb)

Variables
PFSN_PREFETCHER_GLOBALS	CcPfGlobals
LONG	CcOutstandingDeletes
KEVENT	CcpLazyWriteEvent
KEVENT	CcFinalizeEvent
HANDLE	CcUnmapThreadHandle
HANDLE	CcLazyWriteThreadHandle
CLIENT_ID	CcUnmapThreadId
CLIENT_ID	CcLazyWriteThreadId
FAST_MUTEX	GlobalPageOperation
LIST_ENTRY	CcpAllSharedCacheMaps

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 15 of file fssup.c.

Typedef Documentation

NOCC_PRIVATE_CACHE_MAP

typedef struct _NOCC_PRIVATE_CACHE_MAP NOCC_PRIVATE_CACHE_MAP

PNOCC_PRIVATE_CACHE_MAP

typedef struct _NOCC_PRIVATE_CACHE_MAP * PNOCC_PRIVATE_CACHE_MAP

Function Documentation

CcGetFileObjectFromBcb()

PFILE_OBJECT NTAPI CcGetFileObjectFromBcb

(

PVOID

Bcb

)

Definition at line 625 of file fssup.c.

{
    PNOCC_BCB RealBcb = (PNOCC_BCB)Bcb;
    DPRINT("BCB #%x\n", RealBcb - CcCacheSections);
    return MmGetFileObjectForSection((PROS_SECTION_OBJECT)RealBcb->SectionObject);
}

Referenced by FatUnpinRepinnedBcbs().

CcGetFileObjectFromSectionPtrs()

PFILE_OBJECT NTAPI CcGetFileObjectFromSectionPtrs

(

IN PSECTION_OBJECT_POINTERS

SectionObjectPointer

)

Definition at line 606 of file fssup.c.

{
    PFILE_OBJECT Result = NULL;
    PNOCC_CACHE_MAP Map = SectionObjectPointer->SharedCacheMap;
    CcpLock();
    if (!IsListEmpty(&Map->AssociatedBcb))
    {
        PNOCC_BCB Bcb = CONTAINING_RECORD(Map->AssociatedBcb.Flink,
                                          NOCC_BCB,
                                          ThisFileList);
 
        Result = MmGetFileObjectForSection((PROS_SECTION_OBJECT)Bcb->SectionObject);
    }
    CcpUnlock();
    return Result;
}

CcGetFileSizes()

BOOLEAN NTAPI CcGetFileSizes	(	IN PFILE_OBJECT	FileObject,
		IN PCC_FILE_SIZES	FileSizes
	)

Definition at line 375 of file fssup.c.

{
    PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
    if (!Map) return FALSE;
    *FileSizes = Map->FileSizes;
    return TRUE;
}

CcInitializeCacheManager()

BOOLEAN NTAPI CcInitializeCacheManager

(

VOID

)

Definition at line 83 of file fssup.c.

{
    int i;
 
    DPRINT("Initialize\n");
    for (i = 0; i < CACHE_NUM_SECTIONS; i++)
    {
        KeInitializeEvent(&CcCacheSections[i].ExclusiveWait,
                          SynchronizationEvent,
                          FALSE);
 
        InitializeListHead(&CcCacheSections[i].ThisFileList);
    }
 
    InitializeListHead(&CcpAllSharedCacheMaps);
 
    KeInitializeEvent(&CcDeleteEvent, SynchronizationEvent, FALSE);
    KeInitializeEvent(&CcFinalizeEvent, SynchronizationEvent, FALSE);
    KeInitializeEvent(&CcpLazyWriteEvent, SynchronizationEvent, FALSE);
 
    CcCacheBitmap->Buffer = ((PULONG)&CcCacheBitmap[1]);
    CcCacheBitmap->SizeOfBitMap = ROUND_UP(CACHE_NUM_SECTIONS, 32);
    DPRINT1("Cache has %d entries\n", CcCacheBitmap->SizeOfBitMap);
    ExInitializeFastMutex(&CcMutex);
 
    return TRUE;
}

Referenced by Phase1InitializationDiscard().

CcInitializeCacheMap()

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

Definition at line 195 of file fssup.c.

{
    PNOCC_CACHE_MAP Map = FileObject->SectionObjectPointer->SharedCacheMap;
    PNOCC_PRIVATE_CACHE_MAP PrivateCacheMap = FileObject->PrivateCacheMap;
 
    CcpLock();
    /* We don't have a shared cache map.  First find out if we have a sibling
       stream file object we can take it from. */
    if (!Map && FileObject->Flags & FO_STREAM_FILE)
    {
        PFILE_OBJECT IdenticalStreamFileObject = CcpFindOtherStreamFileObject(FileObject);
        if (IdenticalStreamFileObject)
            Map = IdenticalStreamFileObject->SectionObjectPointer->SharedCacheMap;
        if (Map)
        {
            DPRINT1("Linking SFO %x to previous SFO %x through cache map %x #\n",
                    FileObject,
                    IdenticalStreamFileObject,
                    Map);
        }
    }
    /* We still don't have a shared cache map.  We need to create one. */
    if (!Map)
    {
        DPRINT("Initializing file object for (%p) %wZ\n",
               FileObject,
               &FileObject->FileName);
 
        Map = ExAllocatePool(NonPagedPool, sizeof(NOCC_CACHE_MAP));
        FileObject->SectionObjectPointer->SharedCacheMap = Map;
        Map->FileSizes = *FileSizes;
        Map->LazyContext = LazyWriteContext;
        Map->ReadAheadGranularity = PAGE_SIZE;
        RtlCopyMemory(&Map->Callbacks, Callbacks, sizeof(*Callbacks));
 
        /* For now ... */
        DPRINT("FileSizes->ValidDataLength %I64x\n",
               FileSizes->ValidDataLength.QuadPart);
 
        InitializeListHead(&Map->AssociatedBcb);
        InitializeListHead(&Map->PrivateCacheMaps);
        InsertTailList(&CcpAllSharedCacheMaps, &Map->Entry);
        DPRINT("New Map %p\n", Map);
    }
    /* We don't have a private cache map.  Link it with the shared cache map
       to serve as a held reference. When the list in the shared cache map
       is empty, we know we can delete it. */
    if (!PrivateCacheMap)
    {
        PrivateCacheMap = ExAllocatePool(NonPagedPool,
                                         sizeof(*PrivateCacheMap));
 
        FileObject->PrivateCacheMap = PrivateCacheMap;
        PrivateCacheMap->FileObject = FileObject;
        ObReferenceObject(PrivateCacheMap->FileObject);
    }
 
    PrivateCacheMap->Map = Map;
    InsertTailList(&Map->PrivateCacheMaps, &PrivateCacheMap->ListEntry);
 
    CcpUnlock();
}

Referenced by _Requires_lock_held_(), CdCreateInternalStream(), Ext2InitializeVcb(), Ext2ReadFile(), Ext2WriteFile(), FatInitializeCacheMap(), init_file_cache(), mount_vol(), NtfsAttachFCBToFileObject(), NtfsFCBInitializeCache(), NtfsMountVolume(), PerformTest(), RxCommonRead(), RxCommonWrite(), TestIrpHandler(), UDFCommonRead(), UDFCommonWrite(), UDFSetAllocationInformation(), UDFSetEOF(), VfatCommonRead(), vfatFCBInitializeCacheFromVolume(), VfatMount(), and VfatWrite().

CcpAcquireFileLock()

BOOLEAN NTAPI CcpAcquireFileLock

(

PNOCC_CACHE_MAP

Map

)

Definition at line 131 of file fssup.c.

{
    DPRINT("Calling AcquireForLazyWrite: %x\n", Map->LazyContext);
    return Map->Callbacks.AcquireForLazyWrite(Map->LazyContext, TRUE);
}

CcpCountCacheSections()

ULONG NTAPI CcpCountCacheSections

(

IN PNOCC_CACHE_MAP

Map

)

Definition at line 272 of file fssup.c.

{
    PLIST_ENTRY Entry;
    ULONG Count;
 
    for (Count = 0, Entry = Map->AssociatedBcb.Flink;
         Entry != &Map->AssociatedBcb;
         Entry = Entry->Flink, Count++);
 
    return Count;
}

CcpFindOtherStreamFileObject()

PFILE_OBJECT CcpFindOtherStreamFileObject

(

PFILE_OBJECT

FileObject

)

Definition at line 160 of file fssup.c.

{
    PLIST_ENTRY Entry, Private;
    for (Entry = CcpAllSharedCacheMaps.Flink;
         Entry != &CcpAllSharedCacheMaps;
         Entry = Entry->Flink)
    {
        /* 'Identical' test for other stream file object */
        PNOCC_CACHE_MAP Map = CONTAINING_RECORD(Entry, NOCC_CACHE_MAP, Entry);
        for (Private = Map->PrivateCacheMaps.Flink;
             Private != &Map->PrivateCacheMaps;
             Private = Private->Flink)
        {
            PNOCC_PRIVATE_CACHE_MAP PrivateMap = CONTAINING_RECORD(Private,
                                                                   NOCC_PRIVATE_CACHE_MAP,
                                                                   ListEntry);
 
            if (PrivateMap->FileObject->Flags & FO_STREAM_FILE &&
                PrivateMap->FileObject->DeviceObject == FileObject->DeviceObject &&
                PrivateMap->FileObject->Vpb == FileObject->Vpb &&
                PrivateMap->FileObject->FsContext == FileObject->FsContext &&
                PrivateMap->FileObject->FsContext2 == FileObject->FsContext2 &&
                1)
            {
                return PrivateMap->FileObject;
            }
        }
    }
    return 0;
}

Referenced by CcInitializeCacheMap().

CcPfInitializePrefetcher()

VOID NTAPI CcPfInitializePrefetcher

(

VOID

)

Definition at line 114 of file fssup.c.

{
    /* Notify debugger */
    DbgPrintEx(DPFLTR_PREFETCHER_ID,
               DPFLTR_TRACE_LEVEL,
               "CCPF: InitializePrefetecher()\n");
 
    /* Setup the Prefetcher Data */
    InitializeListHead(&CcPfGlobals.ActiveTraces);
    InitializeListHead(&CcPfGlobals.CompletedTraces);
    ExInitializeFastMutex(&CcPfGlobals.CompletedTracesLock);
 
    /* FIXME: Setup the rest of the prefetecher */
}

Referenced by Phase1InitializationDiscard().

CcpLazyWriteThread()

VOID NTAPI CcpLazyWriteThread

(

PVOID

Unused

)

Definition at line 23 of file lazyrite.c.

{
    /* Not implemented */
}

CcpReleaseFileLock()

VOID NTAPI CcpReleaseFileLock

(

PNOCC_CACHE_MAP

Map

)

Definition at line 139 of file fssup.c.

{
    DPRINT("Releasing Lazy Write %x\n", Map->LazyContext);
    Map->Callbacks.ReleaseFromLazyWrite(Map->LazyContext);
}

CcpUnmapThread()

VOID NTAPI CcpUnmapThread

(

PVOID

Unused

)

CcPurgeCacheSection()

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

Definition at line 386 of file fssup.c.

{
    PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap;
    if (!Map) return TRUE;
    CcpFlushCache(Map, NULL, 0, NULL, TRUE);
    return TRUE;
}

Referenced by __attribute__(), _Dispatch_type_(), _Requires_lock_held_(), CcFlushImageSection(), CdCreateInternalStream(), duplicate_extents(), Ext2Cleanup(), Ext2CreateFile(), Ext2PurgeFile(), Ext2PurgeVolume(), Ext2ReadFile(), Ext2SupersedeOrOverWriteFile(), Ext2WriteFile(), Ext2WriteVolume(), FatUnpinRepinnedBcbs(), RxChangeBufferingState(), RxCommonWrite(), RxPurgeFcbInSystemCache(), set_zero_data(), TestIrpHandler(), UDFCloseAllXXXDelayedInDir(), UDFCommonCleanup(), UDFCommonCreate(), UDFCommonWrite(), and UDFPurgeCacheEx_().

CcSetDirtyPageThreshold()

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

Definition at line 399 of file fssup.c.

{
    UNIMPLEMENTED_DBGBREAK();
}

CcSetFileSizes()

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

Definition at line 356 of file fssup.c.

{
    PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
    PNOCC_BCB Bcb;
 
    if (!Map) return;
    Map->FileSizes = *FileSizes;
    Bcb = Map->AssociatedBcb.Flink == &Map->AssociatedBcb ?
        NULL : CONTAINING_RECORD(Map->AssociatedBcb.Flink, NOCC_BCB, ThisFileList);
    if (!Bcb) return;
    MmExtendCacheSection(Bcb->SectionObject, &FileSizes->FileSize, FALSE);
    DPRINT("FileSizes->FileSize %x\n", FileSizes->FileSize.LowPart);
    DPRINT("FileSizes->AllocationSize %x\n", FileSizes->AllocationSize.LowPart);
    DPRINT("FileSizes->ValidDataLength %x\n", FileSizes->ValidDataLength.LowPart);
}

Referenced by __attribute__(), _Requires_lock_held_(), CdCreateInternalStream(), delete_fileref_fcb(), Ext2Cleanup(), Ext2SetFileInformation(), Ext2SupersedeOrOverWriteFile(), Ext2WriteFile(), FatSetupAllocationSupport(), PerformTest(), RxCollapseOrCreateSrvOpen(), RxCommonWrite(), set_end_of_file_information(), set_valid_data_length_information(), SetAttributeDataLength(), TestIrpHandler(), UDFCommonCleanup(), UDFCommonCreate(), UDFCommonWrite(), UDFSetAllocationInformation(), UDFSetEOF(), and UpdateFileSize().

CcUninitializeCacheMap()

BOOLEAN NTAPI CcUninitializeCacheMap	(	IN PFILE_OBJECT	FileObject,
		IN OPTIONAL PLARGE_INTEGER TruncateSize	,
		IN OPTIONAL PCACHE_UNINITIALIZE_EVENT	UninitializeEvent
	)

Definition at line 286 of file fssup.c.

{
    BOOLEAN LastMap = FALSE;
    PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
    PNOCC_PRIVATE_CACHE_MAP PrivateCacheMap = FileObject->PrivateCacheMap;
 
    DPRINT("Uninitializing file object for %wZ SectionObjectPointer %x\n",
           &FileObject->FileName,
           FileObject->SectionObjectPointer);
 
    ASSERT(UninitializeEvent == NULL);
 
    /* It may not be strictly necessary to flush here, but we do just for
       kicks. */
    if (Map)
        CcpFlushCache(Map, NULL, 0, NULL, FALSE);
 
    CcpLock();
    /* We have a private cache map, so we've been initialized and haven't been
     * uninitialized. */
    if (PrivateCacheMap)
    {
        ASSERT(!Map || Map == PrivateCacheMap->Map);
        ASSERT(PrivateCacheMap->FileObject == FileObject);
 
        RemoveEntryList(&PrivateCacheMap->ListEntry);
        /* That was the last private cache map.  It's time to delete all
           cache stripes and all aspects of caching on the file. */
        if (IsListEmpty(&PrivateCacheMap->Map->PrivateCacheMaps))
        {
            /* Get rid of all the cache stripes. */
            while (!IsListEmpty(&PrivateCacheMap->Map->AssociatedBcb))
            {
                PNOCC_BCB Bcb = CONTAINING_RECORD(PrivateCacheMap->Map->AssociatedBcb.Flink,
                                                  NOCC_BCB,
                                                  ThisFileList);
 
                DPRINT("Evicting cache stripe #%x\n", Bcb - CcCacheSections);
                Bcb->RefCount = 1;
                CcpDereferenceCache(Bcb - CcCacheSections, TRUE);
            }
            RemoveEntryList(&PrivateCacheMap->Map->Entry);
            ExFreePool(PrivateCacheMap->Map);
            FileObject->SectionObjectPointer->SharedCacheMap = NULL;
            LastMap = TRUE;
        }
        ObDereferenceObject(PrivateCacheMap->FileObject);
        FileObject->PrivateCacheMap = NULL;
        ExFreePool(PrivateCacheMap);
    }
    CcpUnlock();
 
    DPRINT("Uninit complete\n");
 
    /* The return from CcUninitializeCacheMap means that 'caching was stopped'. */
    return LastMap;
}

Referenced by _Dispatch_type_(), _Requires_lock_held_(), CdDeleteInternalStream(), CleanupTest(), close_file(), delete_fileref(), Ext2Cleanup(), Ext2SyncUninitializeCacheMap(), FatSetRenameInfo(), FatSyncUninitializeCacheMap(), FatTearDownVcb(), NtfsCleanupFile(), NtfsReleaseFCB(), RxUninitializeCacheMap(), TestIrpHandler(), UDFCommonCleanup(), UDFSetAllocationInformation(), UDFSetEOF(), VfatCheckForDismount(), VfatCleanupFile(), VfatCommonCloseFile(), VfatMount(), and vfatReleaseFCB().

CcZeroData()

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

Definition at line 414 of file fssup.c.

{
    PNOCC_BCB Bcb = NULL;
    PLIST_ENTRY ListEntry = NULL;
    LARGE_INTEGER LowerBound = *StartOffset;
    LARGE_INTEGER UpperBound = *EndOffset;
    LARGE_INTEGER Target, End;
    PVOID PinnedBcb, PinnedBuffer;
    PNOCC_CACHE_MAP Map = FileObject->SectionObjectPointer->SharedCacheMap;
 
    DPRINT("S %I64x E %I64x\n",
           StartOffset->QuadPart,
           EndOffset->QuadPart);
 
    if (!Map)
    {
        NTSTATUS Status;
        IO_STATUS_BLOCK IOSB;
        PCHAR ZeroBuf = ExAllocatePool(PagedPool, PAGE_SIZE);
        ULONG ToWrite;
 
        if (!ZeroBuf) RtlRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
        DPRINT1("RtlZeroMemory(%x,%x)\n", ZeroBuf, PAGE_SIZE);
        RtlZeroMemory(ZeroBuf, PAGE_SIZE);
 
        Target.QuadPart = PAGE_ROUND_DOWN(LowerBound.QuadPart);
        End.QuadPart = PAGE_ROUND_UP(UpperBound.QuadPart);
 
        // Handle leading page
        if (LowerBound.QuadPart != Target.QuadPart)
        {
            ToWrite = MIN(UpperBound.QuadPart - LowerBound.QuadPart,
                          (PAGE_SIZE - LowerBound.QuadPart) & (PAGE_SIZE - 1));
 
            DPRINT("Zero last half %I64x %lx\n",
                   Target.QuadPart,
                   ToWrite);
 
            Status = MiSimpleRead(FileObject,
                                  &Target,
                                  ZeroBuf,
                                  PAGE_SIZE,
                                  TRUE,
                                  &IOSB);
 
            if (!NT_SUCCESS(Status))
            {
                ExFreePool(ZeroBuf);
                RtlRaiseStatus(Status);
            }
 
            DPRINT1("RtlZeroMemory(%p, %lx)\n",
                    ZeroBuf + LowerBound.QuadPart - Target.QuadPart,
                    ToWrite);
 
            RtlZeroMemory(ZeroBuf + LowerBound.QuadPart - Target.QuadPart,
                          ToWrite);
 
            Status = MiSimpleWrite(FileObject,
                                   &Target,
                                   ZeroBuf,
                                   MIN(PAGE_SIZE,
                                       UpperBound.QuadPart-Target.QuadPart),
                                   &IOSB);
 
            if (!NT_SUCCESS(Status))
            {
                ExFreePool(ZeroBuf);
                RtlRaiseStatus(Status);
            }
            Target.QuadPart += PAGE_SIZE;
        }
 
        DPRINT1("RtlZeroMemory(%x,%x)\n", ZeroBuf, PAGE_SIZE);
        RtlZeroMemory(ZeroBuf, PAGE_SIZE);
 
        while (UpperBound.QuadPart - Target.QuadPart > PAGE_SIZE)
        {
            DPRINT("Zero full page %I64x\n",
                   Target.QuadPart);
 
            Status = MiSimpleWrite(FileObject,
                                   &Target,
                                   ZeroBuf,
                                   PAGE_SIZE,
                                   &IOSB);
 
            if (!NT_SUCCESS(Status))
            {
                ExFreePool(ZeroBuf);
                RtlRaiseStatus(Status);
            }
            Target.QuadPart += PAGE_SIZE;
        }
 
        if (UpperBound.QuadPart > Target.QuadPart)
        {
            ToWrite = UpperBound.QuadPart - Target.QuadPart;
            DPRINT("Zero first half %I64x %lx\n",
                   Target.QuadPart,
                   ToWrite);
 
            Status = MiSimpleRead(FileObject,
                                  &Target,
                                  ZeroBuf,
                                  PAGE_SIZE,
                                  TRUE,
                                  &IOSB);
 
            if (!NT_SUCCESS(Status))
            {
                ExFreePool(ZeroBuf);
                RtlRaiseStatus(Status);
            }
            DPRINT1("RtlZeroMemory(%x,%x)\n", ZeroBuf, ToWrite);
            RtlZeroMemory(ZeroBuf, ToWrite);
            Status = MiSimpleWrite(FileObject,
                                   &Target,
                                   ZeroBuf,
                                   MIN(PAGE_SIZE,
                                       UpperBound.QuadPart-Target.QuadPart),
                                   &IOSB);
            if (!NT_SUCCESS(Status))
            {
                ExFreePool(ZeroBuf);
                RtlRaiseStatus(Status);
            }
            Target.QuadPart += PAGE_SIZE;
        }
 
        ExFreePool(ZeroBuf);
        return TRUE;
    }
 
    CcpLock();
    ListEntry = Map->AssociatedBcb.Flink;
 
    while (ListEntry != &Map->AssociatedBcb)
    {
        Bcb = CONTAINING_RECORD(ListEntry, NOCC_BCB, ThisFileList);
        CcpReferenceCache(Bcb - CcCacheSections);
 
        if (Bcb->FileOffset.QuadPart + Bcb->Length >= LowerBound.QuadPart &&
            Bcb->FileOffset.QuadPart < UpperBound.QuadPart)
        {
            DPRINT("Bcb #%x (@%I64x)\n",
                   Bcb - CcCacheSections,
                   Bcb->FileOffset.QuadPart);
 
            Target.QuadPart = MAX(Bcb->FileOffset.QuadPart,
                                  LowerBound.QuadPart);
 
            End.QuadPart = MIN(Map->FileSizes.ValidDataLength.QuadPart,
                               UpperBound.QuadPart);
 
            End.QuadPart = MIN(End.QuadPart,
                               Bcb->FileOffset.QuadPart + Bcb->Length);
 
            CcpUnlock();
 
            if (!CcPreparePinWrite(FileObject,
                                   &Target,
                                   End.QuadPart - Target.QuadPart,
                                   TRUE,
                                   Wait,
                                   &PinnedBcb,
                                   &PinnedBuffer))
            {
                return FALSE;
            }
 
            ASSERT(PinnedBcb == Bcb);
 
            CcpLock();
            ListEntry = ListEntry->Flink;
            /* Return from pin state */
            CcpUnpinData(PinnedBcb, TRUE);
        }
 
        CcpUnpinData(Bcb, TRUE);
    }
 
    CcpUnlock();
 
    return TRUE;
}

Referenced by Ext2Cleanup(), Ext2ZeroData(), FatZeroData(), FsRtlCopyWrite(), FsRtlCopyWrite2(), FsRtlPrepareMdlWriteDev(), and VfatWrite().

Variable Documentation

CcFinalizeEvent

KEVENT CcFinalizeEvent

extern

Definition at line 103 of file pinsup.c.

Referenced by CcInitializeCacheManager().

CcLazyWriteThreadHandle

HANDLE CcLazyWriteThreadHandle

Definition at line 26 of file fssup.c.

CcLazyWriteThreadId

CLIENT_ID CcLazyWriteThreadId

Definition at line 27 of file fssup.c.

CcOutstandingDeletes

LONG CcOutstandingDeletes

extern

Definition at line 105 of file pinsup.c.

CcpAllSharedCacheMaps

LIST_ENTRY CcpAllSharedCacheMaps

Definition at line 76 of file fssup.c.

Referenced by CcInitializeCacheManager(), CcInitializeCacheMap(), and CcpFindOtherStreamFileObject().

CcPfGlobals

PFSN_PREFETCHER_GLOBALS CcPfGlobals

Definition at line 20 of file fssup.c.

Referenced by CcPfInitializePrefetcher().

CcpLazyWriteEvent

KEVENT CcpLazyWriteEvent

extern

Definition at line 18 of file lazyrite.c.

Referenced by CcInitializeCacheManager().

CcUnmapThreadHandle

HANDLE CcUnmapThreadHandle

Definition at line 26 of file fssup.c.

CcUnmapThreadId

CLIENT_ID CcUnmapThreadId

Definition at line 27 of file fssup.c.

GlobalPageOperation

FAST_MUTEX GlobalPageOperation

Definition at line 28 of file fssup.c.