newcc.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_NOCC_BCB
struct	_NOCC_CACHE_MAP

Macros
#define	CcpFlushCache(M, F, L, I, D)   _CcpFlushCache(M,F,L,I,D,__FILE__,__LINE__)
#define	KEBUGCHECKCC
#define	CACHE_SINGLE_FILE_MAX   (16)
#define	CACHE_OVERALL_SIZE   (32 * 1024 * 1024)
#define	CACHE_STRIPE   VACB_MAPPING_GRANULARITY
#define	CACHE_SHIFT   18
#define	CACHE_NUM_SECTIONS   (CACHE_OVERALL_SIZE / CACHE_STRIPE)
#define	CACHE_ROUND_UP(x)   (((x) + (CACHE_STRIPE-1)) & ~(CACHE_STRIPE-1))
#define	CACHE_ROUND_DOWN(x)   ((x) & ~(CACHE_STRIPE-1))
#define	INVALID_CACHE   ((ULONG)~0)
#define	CcpLock()   _CcpLock(__FILE__,__LINE__)
#define	CcpUnlock()   _CcpUnlock(__FILE__,__LINE__)

Typedefs
typedef struct _NOCC_BCB	NOCC_BCB
typedef struct _NOCC_BCB *	PNOCC_BCB
typedef struct _NOCC_CACHE_MAP	NOCC_CACHE_MAP
typedef struct _NOCC_CACHE_MAP *	PNOCC_CACHE_MAP

Functions
VOID NTAPI	CcPfInitializePrefetcher (VOID)
VOID NTAPI	CcMdlReadComplete2 (IN PFILE_OBJECT FileObject, IN PMDL MemoryDescriptorList)
VOID NTAPI	CcMdlWriteComplete2 (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PMDL MdlChain)
VOID NTAPI	CcInitView (VOID)
BOOLEAN NTAPI	CcpUnpinData (PNOCC_BCB Bcb, BOOLEAN ActuallyRelease)
VOID NTAPI	CcShutdownSystem (VOID)
VOID NTAPI	CcInitCacheZeroPage (VOID)
BOOLEAN NTAPI	CcFlushImageSection (PSECTION_OBJECT_POINTERS SectionObjectPointer, MMFLUSH_TYPE FlushType)
VOID NTAPI	_CcpFlushCache (IN PNOCC_CACHE_MAP Map, IN OPTIONAL PLARGE_INTEGER FileOffset, IN ULONG Length, OUT OPTIONAL PIO_STATUS_BLOCK IoStatus, BOOLEAN Delete, const char *File, int Line)
BOOLEAN NTAPI	CcGetFileSizes (PFILE_OBJECT FileObject, PCC_FILE_SIZES FileSizes)
ULONG NTAPI	CcpCountCacheSections (PNOCC_CACHE_MAP Map)
BOOLEAN NTAPI	CcpAcquireFileLock (PNOCC_CACHE_MAP Map)
VOID NTAPI	CcpReleaseFileLock (PNOCC_CACHE_MAP Map)
VOID	_CcpLock (const char *file, int line)
VOID	_CcpUnlock (const char *file, int line)
VOID	CcpReferenceCache (ULONG Sector)
VOID	CcpDereferenceCache (ULONG Sector, BOOLEAN Immediate)
BOOLEAN NTAPI	CcpMapData (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG Flags, OUT PVOID *BcbResult, OUT PVOID *Buffer)
BOOLEAN NTAPI	CcpPinMappedData (IN PNOCC_CACHE_MAP Map, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG Flags, IN OUT PVOID *Bcb)
ULONG	MmGetReferenceCountPageWithoutLock (PFN_NUMBER Page)

Variables
NOCC_BCB	CcCacheSections [CACHE_NUM_SECTIONS]
PRTL_BITMAP	CcCacheBitmap
FAST_MUTEX	CcMutex
KEVENT	CcDeleteEvent
ULONG	CcCacheClockHand
LIST_ENTRY	CcPendingUnmap
KEVENT	CcpLazyWriteEvent

Macro Definition Documentation

CACHE_NUM_SECTIONS

#define CACHE_NUM_SECTIONS   (CACHE_OVERALL_SIZE / CACHE_STRIPE)

Definition at line 125 of file newcc.h.

CACHE_OVERALL_SIZE

#define CACHE_OVERALL_SIZE   (32 * 1024 * 1024)

Definition at line 122 of file newcc.h.

CACHE_ROUND_DOWN

#define CACHE_ROUND_DOWN

(

x

)

((x) & ~(CACHE_STRIPE-1))

Definition at line 127 of file newcc.h.

CACHE_ROUND_UP

#define CACHE_ROUND_UP

(

x

)

(((x) + (CACHE_STRIPE-1)) & ~(CACHE_STRIPE-1))

Definition at line 126 of file newcc.h.

CACHE_SHIFT

#define CACHE_SHIFT   18

Definition at line 124 of file newcc.h.

CACHE_SINGLE_FILE_MAX

#define CACHE_SINGLE_FILE_MAX   (16)

Definition at line 121 of file newcc.h.

CACHE_STRIPE

#define CACHE_STRIPE   VACB_MAPPING_GRANULARITY

Definition at line 123 of file newcc.h.

CcpFlushCache

#define CcpFlushCache	(		M,
			F,
			L,
			I,
			D
	)		_CcpFlushCache(M,F,L,I,D,__FILE__,__LINE__)

Definition at line 91 of file newcc.h.

CcpLock

#define CcpLock

(

)

_CcpLock(__FILE__,__LINE__)

Definition at line 138 of file newcc.h.

CcpUnlock

#define CcpUnlock

(

)

_CcpUnlock(__FILE__,__LINE__)

Definition at line 139 of file newcc.h.

INVALID_CACHE

#define INVALID_CACHE   ((ULONG)~0)

Definition at line 128 of file newcc.h.

KEBUGCHECKCC

#define KEBUGCHECKCC

Value:

KEBUGCHECKEX(CACHE_MANAGER, \
    (*(ULONG*)(__FILE__ + sizeof(__FILE__) - 4) << 16) | \
    (__LINE__ & 0xFFFF), 0, 0, 0)

Definition at line 114 of file newcc.h.

Typedef Documentation

NOCC_BCB

typedef struct _NOCC_BCB NOCC_BCB

NOCC_CACHE_MAP

typedef struct _NOCC_CACHE_MAP NOCC_CACHE_MAP

PNOCC_BCB

typedef struct _NOCC_BCB * PNOCC_BCB

PNOCC_CACHE_MAP

typedef struct _NOCC_CACHE_MAP * PNOCC_CACHE_MAP

Function Documentation

_CcpFlushCache()

VOID NTAPI _CcpFlushCache	(	IN PNOCC_CACHE_MAP	Map,
		IN OPTIONAL PLARGE_INTEGER	FileOffset,
		IN ULONG	Length,
		OUT OPTIONAL PIO_STATUS_BLOCK	IoStatus,
		BOOLEAN	Delete,
		const char *	File,
		int	Line
	)

Definition at line 142 of file cachesub.c.

{
    PNOCC_BCB Bcb = NULL;
    LARGE_INTEGER LowerBound, UpperBound;
    PLIST_ENTRY ListEntry;
    IO_STATUS_BLOCK IOSB;

    RtlZeroMemory(&IOSB, sizeof(IO_STATUS_BLOCK));

    DPRINT("CcFlushCache (while file) (%s:%d)\n", File, Line);

    if (FileOffset && Length)
    {
        LowerBound.QuadPart = FileOffset->QuadPart;
        UpperBound.QuadPart = LowerBound.QuadPart + Length;
    }
    else
    {
        LowerBound.QuadPart = 0;
        UpperBound.QuadPart = 0x7fffffffffffffffull;
    }

    CcpLock();
    ListEntry = Map->AssociatedBcb.Flink;

    while (ListEntry != &Map->AssociatedBcb)
    {
        Bcb = CONTAINING_RECORD(ListEntry, NOCC_BCB, ThisFileList);
        CcpReferenceCache((ULONG)(Bcb - CcCacheSections));

        if (Bcb->FileOffset.QuadPart + Bcb->Length >= LowerBound.QuadPart &&
            Bcb->FileOffset.QuadPart < UpperBound.QuadPart)
        {
            DPRINT("Bcb #%x (@%08x%08x)\n",
                   Bcb - CcCacheSections,
                   Bcb->FileOffset.u.HighPart, Bcb->FileOffset.u.LowPart);

            Bcb->RefCount++;
            CcpUnlock();
            MiFlushMappedSection(Bcb->BaseAddress,
                                 &Bcb->FileOffset,
                                 &Map->FileSizes.FileSize,
                                 Bcb->Dirty);
            CcpLock();
            Bcb->RefCount--;

            Bcb->Dirty = FALSE;

            ListEntry = ListEntry->Flink;
            if (Delete && Bcb->RefCount < 2)
            {
                Bcb->RefCount = 1;
                CcpDereferenceCache((ULONG)(Bcb - CcCacheSections), FALSE);
            }
            else
            {
                CcpUnpinData(Bcb, TRUE);
            }
        }
        else
        {
            ListEntry = ListEntry->Flink;
            CcpUnpinData(Bcb, TRUE);
        }

        DPRINT("End loop\n");
    }
    CcpUnlock();

    if (IoStatus) *IoStatus = IOSB;
}

_CcpLock()

VOID _CcpLock	(	const char *	file,
		int	line
	)

Definition at line 112 of file pinsup.c.

{
    //DPRINT("<<<---<<< CC In Mutex(%s:%d %x)!\n", file, line, PsGetCurrentThread());
    ExAcquireFastMutex(&CcMutex);
}

_CcpUnlock()

VOID _CcpUnlock	(	const char *	file,
		int	line
	)

Definition at line 120 of file pinsup.c.

{
    ExReleaseFastMutex(&CcMutex);
    //DPRINT(">>>--->>> CC Exit Mutex!\n", file, line);
}

CcFlushImageSection()

BOOLEAN NTAPI CcFlushImageSection	(	PSECTION_OBJECT_POINTERS	SectionObjectPointer,
		MMFLUSH_TYPE	FlushType
	)

Definition at line 245 of file cachesub.c.

{
    PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap;
    PNOCC_BCB Bcb;
    PLIST_ENTRY Entry;
    IO_STATUS_BLOCK IOSB;
    BOOLEAN Result = TRUE;

    if (!Map) return TRUE;

    for (Entry = Map->AssociatedBcb.Flink;
         Entry != &Map->AssociatedBcb;
         Entry = Entry->Flink)
    {
        Bcb = CONTAINING_RECORD(Entry, NOCC_BCB, ThisFileList);

        if (!Bcb->Dirty) continue;

        switch (FlushType)
        {
            case MmFlushForDelete:
                CcPurgeCacheSection(SectionObjectPointer,
                                    &Bcb->FileOffset,
                                    Bcb->Length,
                                    FALSE);
                break;
            case MmFlushForWrite:
                CcFlushCache(SectionObjectPointer,
                             &Bcb->FileOffset,
                             Bcb->Length,
                             &IOSB);
                break;
        }
    }

    return Result;
}

CcGetFileSizes()

BOOLEAN NTAPI CcGetFileSizes	(	PFILE_OBJECT	FileObject,
		PCC_FILE_SIZES	FileSizes
	)

CcInitCacheZeroPage()

VOID NTAPI CcInitCacheZeroPage

(

VOID

)

Definition at line 56 of file copy.c.

{
    NTSTATUS Status;

    MI_SET_USAGE(MI_USAGE_CACHE);
    //MI_SET_PROCESS2(PsGetCurrentProcess()->ImageFileName);
    Status = MmRequestPageMemoryConsumer(MC_SYSTEM, TRUE, &CcZeroPage);
    if (!NT_SUCCESS(Status))
    {
        DbgPrint("Can't allocate CcZeroPage.\n");
        KeBugCheck(CACHE_MANAGER);
    }
    MiZeroPhysicalPage(CcZeroPage);
}

Referenced by CcInitView().

CcInitView()

VOID NTAPI CcInitView

(

VOID

)

Definition at line 1355 of file view.c.

{
    DPRINT("CcInitView()\n");

    InitializeListHead(&DirtyVacbListHead);
    InitializeListHead(&VacbLruListHead);
    InitializeListHead(&CcDeferredWrites);
    InitializeListHead(&CcCleanSharedCacheMapList);
    KeInitializeSpinLock(&CcDeferredWriteSpinLock);
    ExInitializeNPagedLookasideList(&iBcbLookasideList,
                                    NULL,
                                    NULL,
                                    0,
                                    sizeof(INTERNAL_BCB),
                                    TAG_BCB,
                                    20);
    ExInitializeNPagedLookasideList(&SharedCacheMapLookasideList,
                                    NULL,
                                    NULL,
                                    0,
                                    sizeof(ROS_SHARED_CACHE_MAP),
                                    TAG_SHARED_CACHE_MAP,
                                    20);
    ExInitializeNPagedLookasideList(&VacbLookasideList,
                                    NULL,
                                    NULL,
                                    0,
                                    sizeof(ROS_VACB),
                                    TAG_VACB,
                                    20);

    CcInitCacheZeroPage();
}

Referenced by CcInitializeCacheManager().

CcMdlReadComplete2()

VOID NTAPI CcMdlReadComplete2	(	IN PFILE_OBJECT	FileObject,
		IN PMDL	MemoryDescriptorList
	)

Definition at line 83 of file mdlsup.c.

{
    UNIMPLEMENTED
}

CcMdlWriteComplete2()

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

Definition at line 111 of file mdlsup.c.

{
    UNIMPLEMENTED
}

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

(

PNOCC_CACHE_MAP

Map

)

CcpDereferenceCache()

VOID CcpDereferenceCache	(	ULONG	Sector,
		BOOLEAN	Immediate
	)

Definition at line 213 of file pinsup.c.

{
    PVOID ToUnmap;
    PNOCC_BCB Bcb;
    BOOLEAN Dirty;
    LARGE_INTEGER MappedSize;
    LARGE_INTEGER BaseOffset;
    PWORK_QUEUE_WITH_CONTEXT WorkItem;

    DPRINT("CcpDereferenceCache(#%x)\n", Start);

    Bcb = &CcCacheSections[Start];

    Dirty = Bcb->Dirty;
    ToUnmap = Bcb->BaseAddress;
    BaseOffset = Bcb->FileOffset;
    MappedSize = Bcb->Map->FileSizes.ValidDataLength;

    DPRINT("Dereference #%x (count %d)\n", Start, Bcb->RefCount);
    ASSERT(Bcb->SectionObject);
    ASSERT(Bcb->RefCount == 1);

    DPRINT("Firing work item for %x\n", Bcb->BaseAddress);

    if (Dirty) {
        CcpUnlock();
        Bcb->RefCount++;
        MiFlushMappedSection(ToUnmap, &BaseOffset, &MappedSize, Dirty);
        Bcb->RefCount--;
        CcpLock();
    }

    if (Immediate)
    {
        PROS_SECTION_OBJECT ToDeref = Bcb->SectionObject;
        Bcb->Map = NULL;
        Bcb->SectionObject = NULL;
        Bcb->BaseAddress = NULL;
        Bcb->FileOffset.QuadPart = 0;
        Bcb->Length = 0;
        Bcb->RefCount = 0;
        Bcb->Dirty = FALSE;
        RemoveEntryList(&Bcb->ThisFileList);

        CcpUnlock();
        MmUnmapCacheViewInSystemSpace(ToUnmap);
        ObDereferenceObject(ToDeref);
        CcpLock();
    }
    else
    {
        WorkItem = ExAllocatePool(NonPagedPool, sizeof(*WorkItem));
        if (!WorkItem) KeBugCheck(0);
        WorkItem->ToUnmap = Bcb->BaseAddress;
        WorkItem->FileOffset = Bcb->FileOffset;
        WorkItem->Dirty = Bcb->Dirty;
        WorkItem->MapSize = MappedSize;
        WorkItem->ToDeref = Bcb->SectionObject;
        WorkItem->AcquireForLazyWrite = Bcb->Map->Callbacks.AcquireForLazyWrite;
        WorkItem->ReleaseFromLazyWrite = Bcb->Map->Callbacks.ReleaseFromLazyWrite;
        WorkItem->LazyContext = Bcb->Map->LazyContext;

        ExInitializeWorkItem(&WorkItem->WorkItem,
                             (PWORKER_THREAD_ROUTINE)CcpUnmapCache,
                             WorkItem);

        Bcb->Map = NULL;
        Bcb->SectionObject = NULL;
        Bcb->BaseAddress = NULL;
        Bcb->FileOffset.QuadPart = 0;
        Bcb->Length = 0;
        Bcb->RefCount = 0;
        Bcb->Dirty = FALSE;
        RemoveEntryList(&Bcb->ThisFileList);

        CcpUnlock();
        ExQueueWorkItem(&WorkItem->WorkItem, DelayedWorkQueue);
        CcpLock();
    }
    DPRINT("Done\n");
}

Referenced by _CcpFlushCache(), CcpAllocateCacheSections(), and CcUninitializeCacheMap().

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 */
}

CcpMapData()

BOOLEAN NTAPI CcpMapData	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN ULONG	Length,
		IN ULONG	Flags,
		OUT PVOID *	BcbResult,
		OUT PVOID *	Buffer
	)

Definition at line 465 of file pinsup.c.

{
    BOOLEAN Success = FALSE, FaultIn = FALSE;
    /* Note: windows 2000 drivers treat this as a bool */
    //BOOLEAN Wait = (Flags & MAP_WAIT) || (Flags == TRUE);
    LARGE_INTEGER Target, EndInterval;
    ULONG BcbHead, SectionSize, ViewSize;
    PNOCC_BCB Bcb = NULL;
    PROS_SECTION_OBJECT SectionObject = NULL;
    NTSTATUS Status;
    PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
    ViewSize = CACHE_STRIPE;

    if (!Map)
    {
        DPRINT1("File object was not mapped\n");
        return FALSE;
    }

    DPRINT("CcMapData(F->%x, %I64x:%d)\n",
           FileObject,
           FileOffset->QuadPart,
           Length);

    ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);

    Target.HighPart = FileOffset->HighPart;
    Target.LowPart = CACHE_ROUND_DOWN(FileOffset->LowPart);

    CcpLock();

    /* Find out if any range is a superset of what we want */
    /* Find an accomodating section */
    BcbHead = CcpFindMatchingMap(&Map->AssociatedBcb, FileOffset, Length);

    if (BcbHead != INVALID_CACHE)
    {
        Bcb = &CcCacheSections[BcbHead];
        Success = TRUE;
        *BcbResult = Bcb;
        *Buffer = ((PCHAR)Bcb->BaseAddress) + (int)(FileOffset->QuadPart - Bcb->FileOffset.QuadPart);

        DPRINT("Bcb #%x Buffer maps (%I64x) At %x Length %x (Getting %p:%x) %wZ\n",
               Bcb - CcCacheSections,
               Bcb->FileOffset.QuadPart,
               Bcb->BaseAddress,
               Bcb->Length,
               *Buffer,
               Length,
               &FileObject->FileName);

        DPRINT("w1n\n");
        goto cleanup;
    }

    DPRINT("File size %I64x\n",
           Map->FileSizes.ValidDataLength.QuadPart);

    /* Not all files have length, in fact filesystems often use stream file
       objects for various internal purposes and are loose about the file
       length, since the filesystem promises itself to write the right number
       of bytes to the internal stream.  In these cases, we just allow the file
       to have the full stripe worth of space. */
    if (Map->FileSizes.ValidDataLength.QuadPart)
    {
        SectionSize = min(CACHE_STRIPE,
                          Map->FileSizes.ValidDataLength.QuadPart - Target.QuadPart);
    }
    else
    {
        SectionSize = CACHE_STRIPE;
    }

    DPRINT("Allocating a cache stripe at %x:%d\n",
           Target.LowPart, SectionSize);

    //ASSERT(SectionSize <= CACHE_STRIPE);

    CcpUnlock();
    /* CcpAllocateSection doesn't need the lock, so we'll give other action
       a chance in here. */
    Status = CcpAllocateSection(FileObject,
                                SectionSize,
#ifdef PIN_WRITE_ONLY
                                PAGE_READONLY,
#else
                                PAGE_READWRITE,
#endif
                                &SectionObject);
    CcpLock();

    if (!NT_SUCCESS(Status))
    {
        *BcbResult = NULL;
        *Buffer = NULL;
        DPRINT1("End %08x\n", Status);
        goto cleanup;
    }

retry:
    /* Returns a reference */
    DPRINT("Allocating cache sections: %wZ\n", &FileObject->FileName);
    BcbHead = CcpAllocateCacheSections(FileObject, SectionObject);
    /* XXX todo: we should handle the immediate fail case here, but don't */
    if (BcbHead == INVALID_CACHE)
    {
        ULONG i;
        DbgPrint("Cache Map:");
        for (i = 0; i < CACHE_NUM_SECTIONS; i++)
        {
            if (!(i % 64)) DbgPrint("\n");
            DbgPrint("%c",
                     CcCacheSections[i].RefCount + (RtlTestBit(CcCacheBitmap, i) ? '@' : '`'));
        }
        DbgPrint("\n");

        KeWaitForSingleObject(&CcDeleteEvent,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);

        goto retry;
    }

    DPRINT("BcbHead #%x (final)\n", BcbHead);

    if (BcbHead == INVALID_CACHE)
    {
        *BcbResult = NULL;
        *Buffer = NULL;
        DPRINT1("End\n");
        goto cleanup;
    }

    DPRINT("Selected BCB #%x\n", BcbHead);
    ViewSize = CACHE_STRIPE;

    Bcb = &CcCacheSections[BcbHead];
    /* MmMapCacheViewInSystemSpaceAtOffset is one of three methods of Mm
       that are specific to NewCC.  In this case, it's implementation
       exactly mirrors MmMapViewInSystemSpace, but allows an offset to
       be specified. */
    Status = MmMapCacheViewInSystemSpaceAtOffset(SectionObject->Segment,
                                                 &Bcb->BaseAddress,
                                                 &Target,
                                                 &ViewSize);

    /* Summary: Failure.  Dereference our section and tell the user we failed */
    if (!NT_SUCCESS(Status))
    {
        *BcbResult = NULL;
        *Buffer = NULL;
        ObDereferenceObject(SectionObject);
        RemoveEntryList(&Bcb->ThisFileList);
        RtlZeroMemory(Bcb, sizeof(*Bcb));
        RtlClearBit(CcCacheBitmap, BcbHead);
        DPRINT1("Failed to map\n");
        goto cleanup;
    }

    /* Summary: Success.  Put together a valid Bcb and link it with the others
     * in the NOCC_CACHE_MAP.
     */
    Success = TRUE;

    Bcb->Length = MIN(Map->FileSizes.ValidDataLength.QuadPart - Target.QuadPart,
                      CACHE_STRIPE);

    Bcb->SectionObject = SectionObject;
    Bcb->Map = Map;
    Bcb->FileOffset = Target;
    InsertTailList(&Map->AssociatedBcb, &Bcb->ThisFileList);

    *BcbResult = &CcCacheSections[BcbHead];
    *Buffer = ((PCHAR)Bcb->BaseAddress) + (int)(FileOffset->QuadPart - Bcb->FileOffset.QuadPart);
    FaultIn = TRUE;

    DPRINT("Bcb #%x Buffer maps (%I64x) At %x Length %x (Getting %p:%lx) %wZ\n",
           Bcb - CcCacheSections,
           Bcb->FileOffset.QuadPart,
           Bcb->BaseAddress,
           Bcb->Length,
           *Buffer,
           Length,
           &FileObject->FileName);

    EndInterval.QuadPart = Bcb->FileOffset.QuadPart + Bcb->Length - 1;
    ASSERT((EndInterval.QuadPart & ~(CACHE_STRIPE - 1)) ==
           (Bcb->FileOffset.QuadPart & ~(CACHE_STRIPE - 1)));

cleanup:
    CcpUnlock();
    if (Success)
    {
        if (FaultIn)
        {
            /* Fault in the pages.  This forces reads to happen now. */
            ULONG i;
            PCHAR FaultIn = Bcb->BaseAddress;

            DPRINT("Faulting in pages at this point: file %wZ %I64x:%x\n",
                   &FileObject->FileName,
                   Bcb->FileOffset.QuadPart,
                   Bcb->Length);

            for (i = 0; i < Bcb->Length; i += PAGE_SIZE)
            {
                FaultIn[i] ^= 0;
            }
        }
        ASSERT(Bcb >= CcCacheSections &&
               Bcb < (CcCacheSections + CACHE_NUM_SECTIONS));
    }
    else
    {
        ASSERT(FALSE);
    }

    return Success;
}

Referenced by CcMapData(), and CcPinMappedData().

CcpPinMappedData()

BOOLEAN NTAPI CcpPinMappedData	(	IN PNOCC_CACHE_MAP	Map,
		IN PLARGE_INTEGER	FileOffset,
		IN ULONG	Length,
		IN ULONG	Flags,
		IN OUT PVOID *	Bcb
	)

Definition at line 730 of file pinsup.c.

{
    BOOLEAN Exclusive = Flags & PIN_EXCLUSIVE;
    ULONG BcbHead;
    PNOCC_BCB TheBcb;

    CcpLock();

    ASSERT(Map->AssociatedBcb.Flink == &Map->AssociatedBcb || (CONTAINING_RECORD(Map->AssociatedBcb.Flink, NOCC_BCB, ThisFileList) >= CcCacheSections && CONTAINING_RECORD(Map->AssociatedBcb.Flink, NOCC_BCB, ThisFileList) < CcCacheSections + CACHE_NUM_SECTIONS));
    BcbHead = CcpFindMatchingMap(&Map->AssociatedBcb, FileOffset, Length);
    if (BcbHead == INVALID_CACHE)
    {
        CcpUnlock();
        return FALSE;
    }

    TheBcb = &CcCacheSections[BcbHead];

    if (Exclusive)
    {
        DPRINT("Requesting #%x Exclusive\n", BcbHead);
        CcpMarkForExclusive(BcbHead);
    }
    else
    {
        DPRINT("Reference #%x\n", BcbHead);
        CcpReferenceCache(BcbHead);
    }

    if (Exclusive)
        CcpReferenceCacheExclusive(BcbHead);

    CcpUnlock();

    *Bcb = TheBcb;
    return TRUE;
}

Referenced by CcPinMappedData().

CcpReferenceCache()

VOID CcpReferenceCache

(

ULONG

Sector

)

Definition at line 368 of file pinsup.c.

{
    PNOCC_BCB Bcb;
    Bcb = &CcCacheSections[Start];
    ASSERT(Bcb->SectionObject);
    Bcb->RefCount++;
    RtlSetBit(CcCacheBitmap, Start);

}

Referenced by _CcpFlushCache(), CcMapData(), CcpPinMappedData(), CcRemapBcb(), CcRepinBcb(), CcSetBcbOwnerPointer(), and CcZeroData().

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

CcpUnpinData()

BOOLEAN NTAPI CcpUnpinData	(	PNOCC_BCB	Bcb,
		BOOLEAN	ActuallyRelease
	)

Referenced by _CcpFlushCache(), and CcZeroData().

CcShutdownSystem()

VOID NTAPI CcShutdownSystem

(

VOID

)

Definition at line 299 of file cachesub.c.

{
    ULONG i, Result;
    NTSTATUS Status;

    DPRINT1("CC: Shutdown\n");

    for (i = 0; i < CACHE_NUM_SECTIONS; i++)
    {
        PNOCC_BCB Bcb = &CcCacheSections[i];
        if (Bcb->SectionObject)
        {
            DPRINT1("Evicting #%02x %08x%08x %wZ\n",
                    i,
                    Bcb->FileOffset.u.HighPart,
                    Bcb->FileOffset.u.LowPart,
                    &MmGetFileObjectForSection((PROS_SECTION_OBJECT)Bcb->SectionObject)->FileName);

            CcpFlushCache(Bcb->Map, NULL, 0, NULL, TRUE);
            Bcb->Dirty = FALSE;
        }
    }

    /* Evict all section pages */
    Status = MiRosTrimCache(~0, 0, &Result);

    DPRINT1("Done (Evicted %d, Status %x)\n", Result, Status);
}

MmGetReferenceCountPageWithoutLock()

ULONG MmGetReferenceCountPageWithoutLock

(

PFN_NUMBER

Page

)

Definition at line 165 of file newcc.h.

{
    ULONG Ret;
    KIRQL OldIrql = MiAcquirePfnLock();

    Ret = MmGetReferenceCountPage(Page);

    MiReleasePfnLock(OldIrql);

    return Ret;
}

Referenced by MiFreeSegmentPage(), MmFinalizeSectionPageOut(), and MmpPageOutPhysicalAddress().

Variable Documentation

CcCacheBitmap

PRTL_BITMAP CcCacheBitmap

Definition at line 100 of file pinsup.c.

Referenced by CcInitializeCacheManager(), CcpAllocateCacheSections(), CcpMapData(), CcpReferenceCache(), CcpReferenceCacheExclusive(), CcpUnpinData(), CcRemapBcb(), and CcRepinBcb().

CcCacheClockHand

ULONG CcCacheClockHand

Definition at line 104 of file pinsup.c.

Referenced by CcpAllocateCacheSections().

CcCacheSections

NOCC_BCB CcCacheSections[CACHE_NUM_SECTIONS]

Definition at line 98 of file pinsup.c.

Referenced by _CcpFlushCache(), CcCopyWrite(), CcGetFileObjectFromBcb(), CcInitializeCacheManager(), CcMapData(), CcpAllocateCacheSections(), CcpDereferenceCache(), CcpFindMatchingMap(), CcpMapData(), CcpMarkForExclusive(), CcpPinMappedData(), CcpReferenceCache(), CcpReferenceCacheExclusive(), CcPreparePinWrite(), CcpUnpinData(), CcRemapBcb(), CcRepinBcb(), CcSetBcbOwnerPointer(), CcShutdownSystem(), CcUninitializeCacheMap(), CcUnpinData(), CcUnpinRepinnedBcb(), and CcZeroData().

CcDeleteEvent

KEVENT CcDeleteEvent

Definition at line 102 of file pinsup.c.

Referenced by CcInitializeCacheManager(), CcpMapData(), and CcpUnpinData().

CcMutex

FAST_MUTEX CcMutex

Definition at line 101 of file pinsup.c.

Referenced by _CcpLock(), _CcpUnlock(), and CcInitializeCacheManager().

CcPendingUnmap

LIST_ENTRY CcPendingUnmap

CcpLazyWriteEvent

KEVENT CcpLazyWriteEvent

Definition at line 18 of file lazyrite.c.