cc.h File Reference

Go to the source code of this file.

Classes
struct	_PF_SCENARIO_ID
struct	_PF_LOG_ENTRY
struct	_PFSN_LOG_ENTRIES
struct	_PF_SECTION_INFO
struct	_PF_TRACE_HEADER
struct	_PFSN_TRACE_DUMP
struct	_PFSN_TRACE_HEADER
struct	_PFSN_PREFETCHER_GLOBALS
struct	_ROS_SHARED_CACHE_MAP
struct	_ROS_VACB
struct	_INTERNAL_BCB
struct	_LAZY_WRITER
struct	_WORK_QUEUE_ENTRY

Macros
#define	_CC_DEBUG_   0x00
#define	CC_API_DEBUG   0x01
#define	CCTRACE(x, fmt, ...)   DPRINT(fmt, ##__VA_ARGS__)
#define	READAHEAD_DISABLED   0x1
#define	WRITEBEHIND_DISABLED   0x2
#define	SHARED_CACHE_MAP_IN_CREATION   0x4
#define	SHARED_CACHE_MAP_IN_LAZYWRITE   0x8
#define	NODE_TYPE_DEFERRED_WRITE   0x02FC
#define	NODE_TYPE_PRIVATE_MAP   0x02FE
#define	NODE_TYPE_SHARED_MAP   0x02FF
#define	CcBugCheck(A, B, C)   KeBugCheckEx(CACHE_MANAGER, BugCheckFileId | ((ULONG)(__LINE__)), A, B, C)
#define	CcRosVacbIncRefCount(vacb)   InterlockedIncrement((PLONG)&(vacb)->ReferenceCount)
#define	CcRosVacbGetRefCount(vacb)   InterlockedCompareExchange((PLONG)&(vacb)->ReferenceCount, 0, 0)

Typedefs
typedef struct _PF_SCENARIO_ID	PF_SCENARIO_ID
typedef struct _PF_SCENARIO_ID *	PPF_SCENARIO_ID
typedef struct _PF_LOG_ENTRY	PF_LOG_ENTRY
typedef struct _PF_LOG_ENTRY *	PPF_LOG_ENTRY
typedef struct _PFSN_LOG_ENTRIES	PFSN_LOG_ENTRIES
typedef struct _PFSN_LOG_ENTRIES *	PPFSN_LOG_ENTRIES
typedef struct _PF_SECTION_INFO	PF_SECTION_INFO
typedef struct _PF_SECTION_INFO *	PPF_SECTION_INFO
typedef struct _PF_TRACE_HEADER	PF_TRACE_HEADER
typedef struct _PF_TRACE_HEADER *	PPF_TRACE_HEADER
typedef struct _PFSN_TRACE_DUMP	PFSN_TRACE_DUMP
typedef struct _PFSN_TRACE_DUMP *	PPFSN_TRACE_DUMP
typedef struct _PFSN_TRACE_HEADER	PFSN_TRACE_HEADER
typedef struct _PFSN_TRACE_HEADER *	PPFSN_TRACE_HEADER
typedef struct _PFSN_PREFETCHER_GLOBALS	PFSN_PREFETCHER_GLOBALS
typedef struct _PFSN_PREFETCHER_GLOBALS *	PPFSN_PREFETCHER_GLOBALS
typedef struct _ROS_SHARED_CACHE_MAP	ROS_SHARED_CACHE_MAP
typedef struct _ROS_SHARED_CACHE_MAP *	PROS_SHARED_CACHE_MAP
typedef struct _ROS_VACB	ROS_VACB
typedef struct _ROS_VACB *	PROS_VACB
typedef struct _INTERNAL_BCB	INTERNAL_BCB
typedef struct _INTERNAL_BCB *	PINTERNAL_BCB
typedef struct _LAZY_WRITER	LAZY_WRITER
typedef struct _LAZY_WRITER *	PLAZY_WRITER
typedef struct _WORK_QUEUE_ENTRY	WORK_QUEUE_ENTRY
typedef struct _WORK_QUEUE_ENTRY *	PWORK_QUEUE_ENTRY
typedef enum _WORK_QUEUE_FUNCTIONS	WORK_QUEUE_FUNCTIONS
typedef enum _WORK_QUEUE_FUNCTIONS *	PWORK_QUEUE_FUNCTIONS

Enumerations
enum	_WORK_QUEUE_FUNCTIONS { ReadAhead = 1 , WriteBehind = 2 , LazyScan = 3 , SetDone = 4 }

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)
NTSTATUS	CcRosFlushVacb (_In_ PROS_VACB Vacb, _Out_opt_ PIO_STATUS_BLOCK Iosb)
NTSTATUS	CcRosGetVacb (PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset, PROS_VACB *Vacb)
BOOLEAN	CcRosEnsureVacbResident (_In_ PROS_VACB Vacb, _In_ BOOLEAN Wait, _In_ BOOLEAN NoRead, _In_ ULONG Offset, _In_ ULONG Length)
VOID NTAPI	CcInitView (VOID)
VOID NTAPI	CcShutdownLazyWriter (VOID)
BOOLEAN	CcInitializeCacheManager (VOID)
PROS_VACB	CcRosLookupVacb (PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset)
VOID NTAPI	CcInitCacheZeroPage (VOID)
VOID	CcRosMarkDirtyVacb (PROS_VACB Vacb)
VOID	CcRosUnmarkDirtyVacb (PROS_VACB Vacb, BOOLEAN LockViews)
NTSTATUS	CcRosFlushDirtyPages (ULONG Target, PULONG Count, BOOLEAN Wait, BOOLEAN CalledFromLazy)
VOID	CcRosDereferenceCache (PFILE_OBJECT FileObject)
VOID	CcRosReferenceCache (PFILE_OBJECT FileObject)
NTSTATUS	CcRosReleaseVacb (PROS_SHARED_CACHE_MAP SharedCacheMap, PROS_VACB Vacb, BOOLEAN Dirty, BOOLEAN Mapped)
NTSTATUS	CcRosRequestVacb (PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset, PROS_VACB *Vacb)
NTSTATUS	CcRosInitializeFileCache (PFILE_OBJECT FileObject, PCC_FILE_SIZES FileSizes, BOOLEAN PinAccess, PCACHE_MANAGER_CALLBACKS CallBacks, PVOID LazyWriterContext)
NTSTATUS	CcRosReleaseFileCache (PFILE_OBJECT FileObject)
VOID NTAPI	CcShutdownSystem (VOID)
VOID NTAPI	CcWorkerThread (PVOID Parameter)
VOID NTAPI	CcScanDpc (PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
VOID	CcScheduleLazyWriteScan (BOOLEAN NoDelay)
VOID	CcPostDeferredWrites (VOID)
VOID	CcPostWorkQueue (IN PWORK_QUEUE_ENTRY WorkItem, IN PLIST_ENTRY WorkQueue)
VOID	CcPerformReadAhead (IN PFILE_OBJECT FileObject)
NTSTATUS	CcRosInternalFreeVacb (IN PROS_VACB Vacb)
FORCEINLINE BOOLEAN	DoRangesIntersect (_In_ LONGLONG Offset1, _In_ LONGLONG Length1, _In_ LONGLONG Offset2, _In_ LONGLONG Length2)
FORCEINLINE BOOLEAN	IsPointInRange (_In_ LONGLONG Offset1, _In_ LONGLONG Length1, _In_ LONGLONG Point)
FORCEINLINE ULONG	CcRosVacbDecRefCount (PROS_VACB vacb)
BOOLEAN	CcRosFreeOneUnusedVacb (VOID)

Variables
ULONG	CcRosTraceLevel
LIST_ENTRY	DirtyVacbListHead
ULONG	CcDirtyPageThreshold
ULONG	CcTotalDirtyPages
LIST_ENTRY	CcDeferredWrites
KSPIN_LOCK	CcDeferredWriteSpinLock
ULONG	CcNumberWorkerThreads
LIST_ENTRY	CcIdleWorkerThreadList
LIST_ENTRY	CcExpressWorkQueue
LIST_ENTRY	CcRegularWorkQueue
LIST_ENTRY	CcPostTickWorkQueue
NPAGED_LOOKASIDE_LIST	CcTwilightLookasideList
LARGE_INTEGER	CcIdleDelay
ULONG	CcLazyWritePages
ULONG	CcLazyWriteIos
ULONG	CcMapDataWait
ULONG	CcMapDataNoWait
ULONG	CcPinReadWait
ULONG	CcPinReadNoWait
ULONG	CcPinMappedDataCount
ULONG	CcDataPages
ULONG	CcDataFlushes
LAZY_WRITER	LazyWriter

Macro Definition Documentation

_CC_DEBUG_

#define _CC_DEBUG_   0x00

Definition at line 6 of file cc.h.

CC_API_DEBUG

#define CC_API_DEBUG   0x01

Definition at line 11 of file cc.h.

CcBugCheck

#define CcBugCheck	(		A,
			B,
			C
	)		KeBugCheckEx(CACHE_MANAGER, BugCheckFileId | ((ULONG)(__LINE__)), A, B, C)

Definition at line 470 of file cc.h.

CcRosVacbGetRefCount

#define CcRosVacbGetRefCount

(

vacb

)

InterlockedCompareExchange((PLONG)&(vacb)->ReferenceCount, 0, 0)

Definition at line 511 of file cc.h.

CcRosVacbIncRefCount

#define CcRosVacbIncRefCount

(

vacb

)

InterlockedIncrement((PLONG)&(vacb)->ReferenceCount)

Definition at line 496 of file cc.h.

CCTRACE

#define CCTRACE	(		x,
			fmt,
			...
	)		DPRINT(fmt, ##__VA_ARGS__)

Definition at line 36 of file cc.h.

NODE_TYPE_DEFERRED_WRITE

#define NODE_TYPE_DEFERRED_WRITE   0x02FC

Definition at line 287 of file cc.h.

NODE_TYPE_PRIVATE_MAP

#define NODE_TYPE_PRIVATE_MAP   0x02FE

Definition at line 288 of file cc.h.

NODE_TYPE_SHARED_MAP

#define NODE_TYPE_SHARED_MAP   0x02FF

Definition at line 289 of file cc.h.

READAHEAD_DISABLED

#define READAHEAD_DISABLED   0x1

Definition at line 202 of file cc.h.

SHARED_CACHE_MAP_IN_CREATION

#define SHARED_CACHE_MAP_IN_CREATION   0x4

Definition at line 204 of file cc.h.

SHARED_CACHE_MAP_IN_LAZYWRITE

#define SHARED_CACHE_MAP_IN_LAZYWRITE   0x8

Definition at line 205 of file cc.h.

WRITEBEHIND_DISABLED

#define WRITEBEHIND_DISABLED   0x2

Definition at line 203 of file cc.h.

Typedef Documentation

INTERNAL_BCB

typedef struct _INTERNAL_BCB INTERNAL_BCB

LAZY_WRITER

typedef struct _LAZY_WRITER LAZY_WRITER

PF_LOG_ENTRY

typedef struct _PF_LOG_ENTRY PF_LOG_ENTRY

PF_SCENARIO_ID

typedef struct _PF_SCENARIO_ID PF_SCENARIO_ID

PF_SECTION_INFO

typedef struct _PF_SECTION_INFO PF_SECTION_INFO

PF_TRACE_HEADER

typedef struct _PF_TRACE_HEADER PF_TRACE_HEADER

PFSN_LOG_ENTRIES

typedef struct _PFSN_LOG_ENTRIES PFSN_LOG_ENTRIES

PFSN_PREFETCHER_GLOBALS

typedef struct _PFSN_PREFETCHER_GLOBALS PFSN_PREFETCHER_GLOBALS

PFSN_TRACE_DUMP

typedef struct _PFSN_TRACE_DUMP PFSN_TRACE_DUMP

PFSN_TRACE_HEADER

typedef struct _PFSN_TRACE_HEADER PFSN_TRACE_HEADER

PINTERNAL_BCB

typedef struct _INTERNAL_BCB * PINTERNAL_BCB

PLAZY_WRITER

typedef struct _LAZY_WRITER * PLAZY_WRITER

PPF_LOG_ENTRY

typedef struct _PF_LOG_ENTRY * PPF_LOG_ENTRY

PPF_SCENARIO_ID

typedef struct _PF_SCENARIO_ID * PPF_SCENARIO_ID

PPF_SECTION_INFO

typedef struct _PF_SECTION_INFO * PPF_SECTION_INFO

PPF_TRACE_HEADER

typedef struct _PF_TRACE_HEADER * PPF_TRACE_HEADER

PPFSN_LOG_ENTRIES

typedef struct _PFSN_LOG_ENTRIES * PPFSN_LOG_ENTRIES

PPFSN_PREFETCHER_GLOBALS

typedef struct _PFSN_PREFETCHER_GLOBALS * PPFSN_PREFETCHER_GLOBALS

PPFSN_TRACE_DUMP

typedef struct _PFSN_TRACE_DUMP * PPFSN_TRACE_DUMP

PPFSN_TRACE_HEADER

typedef struct _PFSN_TRACE_HEADER * PPFSN_TRACE_HEADER

PROS_SHARED_CACHE_MAP

typedef struct _ROS_SHARED_CACHE_MAP * PROS_SHARED_CACHE_MAP

PROS_VACB

typedef struct _ROS_VACB * PROS_VACB

PWORK_QUEUE_ENTRY

typedef struct _WORK_QUEUE_ENTRY * PWORK_QUEUE_ENTRY

PWORK_QUEUE_FUNCTIONS

typedef enum _WORK_QUEUE_FUNCTIONS * PWORK_QUEUE_FUNCTIONS

ROS_SHARED_CACHE_MAP

typedef struct _ROS_SHARED_CACHE_MAP ROS_SHARED_CACHE_MAP

ROS_VACB

typedef struct _ROS_VACB ROS_VACB

WORK_QUEUE_ENTRY

typedef struct _WORK_QUEUE_ENTRY WORK_QUEUE_ENTRY

WORK_QUEUE_FUNCTIONS

typedef enum _WORK_QUEUE_FUNCTIONS WORK_QUEUE_FUNCTIONS

Enumeration Type Documentation

_WORK_QUEUE_FUNCTIONS

enum _WORK_QUEUE_FUNCTIONS

Enumerator
ReadAhead
WriteBehind
LazyScan
SetDone

Definition at line 277 of file cc.h.

{
    ReadAhead = 1,
    WriteBehind = 2,
    LazyScan = 3,
    SetDone = 4,
} WORK_QUEUE_FUNCTIONS, *PWORK_QUEUE_FUNCTIONS;

Function Documentation

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

CcInitializeCacheManager()

BOOLEAN 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().

CcInitView()

VOID NTAPI CcInitView

(

VOID

)

Definition at line 1477 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();
}

CcMdlReadComplete2()

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

Definition at line 83 of file mdlsup.c.

{
    UNIMPLEMENTED
}

Referenced by CcMdlReadComplete(), and FsRtlMdlReadCompleteDev().

CcMdlWriteComplete2()

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

Definition at line 111 of file mdlsup.c.

{
    UNIMPLEMENTED
}

Referenced by CcMdlWriteComplete(), and FsRtlMdlWriteCompleteDev().

CcPerformReadAhead()

VOID CcPerformReadAhead

(

IN PFILE_OBJECT

FileObject

)

Definition at line 130 of file copy.c.

{
    NTSTATUS Status;
    LONGLONG CurrentOffset;
    KIRQL OldIrql;
    PROS_SHARED_CACHE_MAP SharedCacheMap;
    PROS_VACB Vacb;
    ULONG PartialLength;
    ULONG Length;
    PPRIVATE_CACHE_MAP PrivateCacheMap;
    BOOLEAN Locked;
    BOOLEAN Success;
 
    SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
 
    /* Critical:
     * PrivateCacheMap might disappear in-between if the handle
     * to the file is closed (private is attached to the handle not to
     * the file), so we need to lock the master lock while we deal with
     * it. It won't disappear without attempting to lock such lock.
     */
    OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
    PrivateCacheMap = FileObject->PrivateCacheMap;
    /* If the handle was closed since the read ahead was scheduled, just quit */
    if (PrivateCacheMap == NULL)
    {
        KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
        ObDereferenceObject(FileObject);
        return;
    }
    /* Otherwise, extract read offset and length and release private map */
    else
    {
        KeAcquireSpinLockAtDpcLevel(&PrivateCacheMap->ReadAheadSpinLock);
        CurrentOffset = PrivateCacheMap->ReadAheadOffset[1].QuadPart;
        Length = PrivateCacheMap->ReadAheadLength[1];
        KeReleaseSpinLockFromDpcLevel(&PrivateCacheMap->ReadAheadSpinLock);
    }
    KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
 
    /* Time to go! */
    DPRINT("Doing ReadAhead for %p\n", FileObject);
    /* Lock the file, first */
    if (!SharedCacheMap->Callbacks->AcquireForReadAhead(SharedCacheMap->LazyWriteContext, FALSE))
    {
        Locked = FALSE;
        goto Clear;
    }
 
    /* Remember it's locked */
    Locked = TRUE;
 
    /* Don't read past the end of the file */
    if (CurrentOffset >= SharedCacheMap->FileSize.QuadPart)
    {
        goto Clear;
    }
    if (CurrentOffset + Length > SharedCacheMap->FileSize.QuadPart)
    {
        Length = SharedCacheMap->FileSize.QuadPart - CurrentOffset;
    }
 
    /* Next of the algorithm will lock like CcCopyData with the slight
     * difference that we don't copy data back to an user-backed buffer
     * We just bring data into Cc
     */
    PartialLength = CurrentOffset % VACB_MAPPING_GRANULARITY;
    if (PartialLength != 0)
    {
        PartialLength = min(Length, VACB_MAPPING_GRANULARITY - PartialLength);
        Status = CcRosRequestVacb(SharedCacheMap,
                                  ROUND_DOWN(CurrentOffset, VACB_MAPPING_GRANULARITY),
                                  &Vacb);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Failed to request VACB: %lx!\n", Status);
            goto Clear;
        }
 
        _SEH2_TRY
        {
            Success = CcRosEnsureVacbResident(Vacb, TRUE, FALSE,
                    CurrentOffset % VACB_MAPPING_GRANULARITY, PartialLength);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Success = FALSE;
        }
        _SEH2_END
 
        if (!Success)
        {
            CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
            DPRINT1("Failed to read data: %lx!\n", Status);
            goto Clear;
        }
 
        CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
 
        Length -= PartialLength;
        CurrentOffset += PartialLength;
    }
 
    while (Length > 0)
    {
        ASSERT(CurrentOffset % VACB_MAPPING_GRANULARITY == 0);
        PartialLength = min(VACB_MAPPING_GRANULARITY, Length);
        Status = CcRosRequestVacb(SharedCacheMap,
                                  CurrentOffset,
                                  &Vacb);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Failed to request VACB: %lx!\n", Status);
            goto Clear;
        }
 
        _SEH2_TRY
        {
            Success = CcRosEnsureVacbResident(Vacb, TRUE, FALSE, 0, PartialLength);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Success = FALSE;
        }
        _SEH2_END
 
        if (!Success)
        {
            CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
            DPRINT1("Failed to read data: %lx!\n", Status);
            goto Clear;
        }
 
        CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
 
        Length -= PartialLength;
        CurrentOffset += PartialLength;
    }
 
Clear:
    /* See previous comment about private cache map */
    OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
    PrivateCacheMap = FileObject->PrivateCacheMap;
    if (PrivateCacheMap != NULL)
    {
        /* Mark read ahead as unactive */
        KeAcquireSpinLockAtDpcLevel(&PrivateCacheMap->ReadAheadSpinLock);
        InterlockedAnd((volatile long *)&PrivateCacheMap->UlongFlags, ~PRIVATE_CACHE_MAP_READ_AHEAD_ACTIVE);
        KeReleaseSpinLockFromDpcLevel(&PrivateCacheMap->ReadAheadSpinLock);
    }
    KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
 
    /* If file was locked, release it */
    if (Locked)
    {
        SharedCacheMap->Callbacks->ReleaseFromReadAhead(SharedCacheMap->LazyWriteContext);
    }
 
    /* And drop our extra reference (See: CcScheduleReadAhead) */
    ObDereferenceObject(FileObject);
 
    return;
}

Referenced by CcWorkerThread().

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().

CcPostDeferredWrites()

VOID CcPostDeferredWrites

(

VOID

)

Definition at line 73 of file copy.c.

{
    LIST_ENTRY ToInsertBack;
 
    InitializeListHead(&ToInsertBack);
 
    /* We'll try to write as much as we can */
    while (TRUE)
    {
        PDEFERRED_WRITE DeferredWrite;
        PLIST_ENTRY ListEntry;
 
        DeferredWrite = NULL;
 
        ListEntry = ExInterlockedRemoveHeadList(&CcDeferredWrites, &CcDeferredWriteSpinLock);
 
        if (!ListEntry)
            break;
 
        DeferredWrite = CONTAINING_RECORD(ListEntry, DEFERRED_WRITE, DeferredWriteLinks);
 
        /* Check if we can write */
        if (CcCanIWrite(DeferredWrite->FileObject, DeferredWrite->BytesToWrite, FALSE, RetryForceCheckPerFile))
        {
            /* If we have an event, set it and go along */
            if (DeferredWrite->Event)
            {
                KeSetEvent(DeferredWrite->Event, IO_NO_INCREMENT, FALSE);
            }
            /* Otherwise, call the write routine and free the context */
            else
            {
                DeferredWrite->PostRoutine(DeferredWrite->Context1, DeferredWrite->Context2);
                ExFreePoolWithTag(DeferredWrite, 'CcDw');
            }
            continue;
        }
 
        /* Keep it for later */
        InsertHeadList(&ToInsertBack, &DeferredWrite->DeferredWriteLinks);
 
        /* If we don't accept modified pages, stop here */
        if (!DeferredWrite->LimitModifiedPages)
        {
            break;
        }
    }
 
    /* Insert what we couldn't write back in the list */
    while (!IsListEmpty(&ToInsertBack))
    {
        PLIST_ENTRY ListEntry = RemoveTailList(&ToInsertBack);
        ExInterlockedInsertHeadList(&CcDeferredWrites, ListEntry, &CcDeferredWriteSpinLock);
    }
}

Referenced by CcCanIWrite(), CcDeferWrite(), and CcLazyWriteScan().

CcPostWorkQueue()

VOID CcPostWorkQueue	(	IN PWORK_QUEUE_ENTRY	WorkItem,
		IN PLIST_ENTRY	WorkQueue
	)

Definition at line 53 of file lazywrite.c.

{
    KIRQL OldIrql;
    PWORK_QUEUE_ITEM ThreadToSpawn;
 
    /* First of all, insert the item in the queue */
    OldIrql = KeAcquireQueuedSpinLock(LockQueueWorkQueueLock);
    InsertTailList(WorkQueue, &WorkItem->WorkQueueLinks);
 
    /* Now, define whether we have to spawn a new work thread
     * We will spawn a new one if:
     * - There's no throttle in action
     * - There's still at least one idle thread
     */
    ThreadToSpawn = NULL;
    if (!CcQueueThrottle && !IsListEmpty(&CcIdleWorkerThreadList))
    {
        PLIST_ENTRY ListEntry;
 
        /* Get the idle thread */
        ListEntry = RemoveHeadList(&CcIdleWorkerThreadList);
        ThreadToSpawn = CONTAINING_RECORD(ListEntry, WORK_QUEUE_ITEM, List);
 
        /* We're going to have one more! */
        CcNumberActiveWorkerThreads += 1;
    }
 
    KeReleaseQueuedSpinLock(LockQueueWorkQueueLock, OldIrql);
 
    /* If we have a thread to spawn, do it! */
    if (ThreadToSpawn != NULL)
    {
        /* We NULLify it to be consistent with initialization */
        ThreadToSpawn->List.Flink = NULL;
        ExQueueWorkItem(ThreadToSpawn, CriticalWorkQueue);
    }
}

Referenced by CcLazyWriteScan(), CcScanDpc(), and CcScheduleReadAhead().

CcRosDereferenceCache()

VOID CcRosDereferenceCache

(

PFILE_OBJECT

FileObject

)

CcRosEnsureVacbResident()

BOOLEAN CcRosEnsureVacbResident	(	_In_ PROS_VACB	Vacb,
		_In_ BOOLEAN	Wait,
		_In_ BOOLEAN	NoRead,
		_In_ ULONG	Offset,
		_In_ ULONG	Length
	)

Definition at line 932 of file view.c.

{
    PROS_SHARED_CACHE_MAP SharedCacheMap = Vacb->SharedCacheMap;
 
    ASSERT((Offset + Length) <= VACB_MAPPING_GRANULARITY);
 
#if 0
    if ((Vacb->FileOffset.QuadPart + Offset) > SharedCacheMap->SectionSize.QuadPart)
    {
        DPRINT1("Vacb read beyond the file size!\n");
        return FALSE;
    }
#endif
 
    /* Check if the pages are resident */
    if (!MmIsDataSectionResident(SharedCacheMap->FileObject->SectionObjectPointer,
                                 Vacb->FileOffset.QuadPart + Offset,
                                 Length))
    {
        if (!Wait)
        {
            return FALSE;
        }
 
        if (!NoRead)
        {
            NTSTATUS Status = MmMakeDataSectionResident(SharedCacheMap->FileObject->SectionObjectPointer,
                                                        Vacb->FileOffset.QuadPart + Offset,
                                                        Length,
                                                        &SharedCacheMap->ValidDataLength);
            if (!NT_SUCCESS(Status))
                ExRaiseStatus(Status);
        }
    }
 
    return TRUE;
}

Referenced by CcCopyRead(), CcCopyWrite(), CcMapData(), CcPerformReadAhead(), CcpPinData(), and CcZeroData().

CcRosFlushDirtyPages()

NTSTATUS CcRosFlushDirtyPages	(	ULONG	Target,
		PULONG	Count,
		BOOLEAN	Wait,
		BOOLEAN	CalledFromLazy
	)

Definition at line 309 of file view.c.

{
    PLIST_ENTRY current_entry;
    NTSTATUS Status;
    KIRQL OldIrql;
    BOOLEAN FlushAll = (Target == MAXULONG);
 
    DPRINT("CcRosFlushDirtyPages(Target %lu)\n", Target);
 
    (*Count) = 0;
 
    KeEnterCriticalRegion();
    OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
 
    current_entry = DirtyVacbListHead.Flink;
    if (current_entry == &DirtyVacbListHead)
    {
        DPRINT("No Dirty pages\n");
    }
 
    while (((current_entry != &DirtyVacbListHead) && (Target > 0)) || FlushAll)
    {
        PROS_SHARED_CACHE_MAP SharedCacheMap;
        PROS_VACB current;
        BOOLEAN Locked;
 
        if (current_entry == &DirtyVacbListHead)
        {
            ASSERT(FlushAll);
            if (IsListEmpty(&DirtyVacbListHead))
                break;
            current_entry = DirtyVacbListHead.Flink;
        }
 
        current = CONTAINING_RECORD(current_entry,
                                    ROS_VACB,
                                    DirtyVacbListEntry);
        current_entry = current_entry->Flink;
 
        CcRosVacbIncRefCount(current);
 
        SharedCacheMap = current->SharedCacheMap;
 
        /* When performing lazy write, don't handle temporary files */
        if (CalledFromLazy && BooleanFlagOn(SharedCacheMap->FileObject->Flags, FO_TEMPORARY_FILE))
        {
            CcRosVacbDecRefCount(current);
            continue;
        }
 
        /* Don't attempt to lazy write the files that asked not to */
        if (CalledFromLazy && BooleanFlagOn(SharedCacheMap->Flags, WRITEBEHIND_DISABLED))
        {
            CcRosVacbDecRefCount(current);
            continue;
        }
 
        ASSERT(current->Dirty);
 
        /* Do not lazy-write the same file concurrently. Fastfat ASSERTS on that */
        if (SharedCacheMap->Flags & SHARED_CACHE_MAP_IN_LAZYWRITE)
        {
            CcRosVacbDecRefCount(current);
            continue;
        }
 
        SharedCacheMap->Flags |= SHARED_CACHE_MAP_IN_LAZYWRITE;
 
        /* Keep a ref on the shared cache map */
        SharedCacheMap->OpenCount++;
 
        KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
 
        Locked = SharedCacheMap->Callbacks->AcquireForLazyWrite(SharedCacheMap->LazyWriteContext, Wait);
        if (!Locked)
        {
            DPRINT("Not locked\n");
            ASSERT(!Wait);
            CcRosVacbDecRefCount(current);
            OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
            SharedCacheMap->Flags &= ~SHARED_CACHE_MAP_IN_LAZYWRITE;
 
            if (--SharedCacheMap->OpenCount == 0)
                CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap, &OldIrql);
 
            continue;
        }
 
        IO_STATUS_BLOCK Iosb;
        Status = CcRosFlushVacb(current, &Iosb);
 
        SharedCacheMap->Callbacks->ReleaseFromLazyWrite(SharedCacheMap->LazyWriteContext);
 
        /* We release the VACB before acquiring the lock again, because
         * CcRosVacbDecRefCount might free the VACB, as CcRosFlushVacb dropped a
         * Refcount. Freeing must be done outside of the lock.
         * The refcount is decremented atomically. So this is OK. */
        CcRosVacbDecRefCount(current);
        OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
 
        SharedCacheMap->Flags &= ~SHARED_CACHE_MAP_IN_LAZYWRITE;
 
        if (--SharedCacheMap->OpenCount == 0)
            CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap, &OldIrql);
 
        if (!NT_SUCCESS(Status) && (Status != STATUS_END_OF_FILE) &&
            (Status != STATUS_MEDIA_WRITE_PROTECTED))
        {
            DPRINT1("CC: Failed to flush VACB.\n");
        }
        else
        {
            ULONG PagesFreed;
 
            /* How many pages did we free? */
            PagesFreed = Iosb.Information / PAGE_SIZE;
            (*Count) += PagesFreed;
 
            if (!Wait)
            {
                /* Make sure we don't overflow target! */
                if (Target < PagesFreed)
                {
                    /* If we would have, jump to zero directly */
                    Target = 0;
                }
                else
                {
                    Target -= PagesFreed;
                }
            }
        }
 
        current_entry = DirtyVacbListHead.Flink;
    }
 
    KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
    KeLeaveCriticalRegion();
 
    DPRINT("CcRosFlushDirtyPages() finished\n");
    return STATUS_SUCCESS;
}

Referenced by CcRosTrimCache(), CcWriteBehind(), and NtSetSystemPowerState().

CcRosFlushVacb()

NTSTATUS CcRosFlushVacb	(	_In_ PROS_VACB	Vacb,
		_Out_opt_ PIO_STATUS_BLOCK	Iosb
	)

Definition at line 163 of file view.c.

{
    NTSTATUS Status;
    BOOLEAN HaveLock = FALSE;
    PROS_SHARED_CACHE_MAP SharedCacheMap = Vacb->SharedCacheMap;
 
    CcRosUnmarkDirtyVacb(Vacb, TRUE);
 
    /* Lock for flush, if we are not already the top-level */
    if (IoGetTopLevelIrp() != (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP)
    {
        Status = FsRtlAcquireFileForCcFlushEx(Vacb->SharedCacheMap->FileObject);
        if (!NT_SUCCESS(Status))
            goto quit;
        HaveLock = TRUE;
    }
 
    Status = MmFlushSegment(SharedCacheMap->FileObject->SectionObjectPointer,
                            &Vacb->FileOffset,
                            VACB_MAPPING_GRANULARITY,
                            Iosb);
 
    if (HaveLock)
    {
        FsRtlReleaseFileForCcFlush(Vacb->SharedCacheMap->FileObject);
    }
 
quit:
    if (!NT_SUCCESS(Status))
        CcRosMarkDirtyVacb(Vacb);
    else
    {
        /* Update VDL */
        if (SharedCacheMap->ValidDataLength.QuadPart < (Vacb->FileOffset.QuadPart + VACB_MAPPING_GRANULARITY))
        {
            SharedCacheMap->ValidDataLength.QuadPart = Vacb->FileOffset.QuadPart + VACB_MAPPING_GRANULARITY;
        }
    }
 
    return Status;
}

Referenced by CcFlushCache(), and CcRosFlushDirtyPages().

CcRosFreeOneUnusedVacb()

BOOLEAN CcRosFreeOneUnusedVacb

(

VOID

)

Definition at line 738 of file view.c.

{
    KIRQL oldIrql;
    PLIST_ENTRY current_entry;
    PROS_VACB to_free = NULL;
 
    oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
 
    /* Browse all the available VACB */
    current_entry = VacbLruListHead.Flink;
    while ((current_entry != &VacbLruListHead) && (to_free == NULL))
    {
        ULONG Refs;
        PROS_VACB current;
 
        current = CONTAINING_RECORD(current_entry,
                                    ROS_VACB,
                                    VacbLruListEntry);
 
        KeAcquireSpinLockAtDpcLevel(&current->SharedCacheMap->CacheMapLock);
 
        /* Only deal with unused VACB, we will free them */
        Refs = CcRosVacbGetRefCount(current);
        if (Refs < 2)
        {
            ASSERT(!current->Dirty);
            ASSERT(!current->MappedCount);
            ASSERT(Refs == 1);
 
            /* Reset it, this is the one we want to free */
            RemoveEntryList(&current->CacheMapVacbListEntry);
            InitializeListHead(&current->CacheMapVacbListEntry);
            RemoveEntryList(&current->VacbLruListEntry);
            InitializeListHead(&current->VacbLruListEntry);
 
            to_free = current;
        }
 
        KeReleaseSpinLockFromDpcLevel(&current->SharedCacheMap->CacheMapLock);
 
        current_entry = current_entry->Flink;
    }
 
    KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
 
    /* And now, free the VACB that we found, if any. */
    if (to_free == NULL)
    {
        return FALSE;
    }
 
    /* This must be its last ref */
    NT_VERIFY(CcRosVacbDecRefCount(to_free) == 0);
 
    return TRUE;
}

Referenced by CcRosCreateVacb(), and CcWriteBehind().

CcRosGetVacb()

NTSTATUS CcRosGetVacb	(	PROS_SHARED_CACHE_MAP	SharedCacheMap,
		LONGLONG	FileOffset,
		PROS_VACB *	Vacb
	)

Definition at line 978 of file view.c.

{
    PROS_VACB current;
    NTSTATUS Status;
    ULONG Refs;
    KIRQL OldIrql;
 
    ASSERT(SharedCacheMap);
 
    DPRINT("CcRosGetVacb()\n");
 
    /*
     * Look for a VACB already mapping the same data.
     */
    current = CcRosLookupVacb(SharedCacheMap, FileOffset);
    if (current == NULL)
    {
        /*
         * Otherwise create a new VACB.
         */
        Status = CcRosCreateVacb(SharedCacheMap, FileOffset, &current);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
    }
 
    Refs = CcRosVacbGetRefCount(current);
 
    OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
 
    /* Move to the tail of the LRU list */
    RemoveEntryList(&current->VacbLruListEntry);
    InsertTailList(&VacbLruListHead, &current->VacbLruListEntry);
 
    KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
 
    /*
     * Return the VACB to the caller.
     */
    *Vacb = current;
 
    ASSERT(Refs > 1);
 
    return STATUS_SUCCESS;
}

Referenced by CcCopyRead(), CcCopyWrite(), CcMapData(), CcpPinData(), CcRosRequestVacb(), and CcZeroData().

CcRosInitializeFileCache()

NTSTATUS CcRosInitializeFileCache	(	PFILE_OBJECT	FileObject,
		PCC_FILE_SIZES	FileSizes,
		BOOLEAN	PinAccess,
		PCACHE_MANAGER_CALLBACKS	CallBacks,
		PVOID	LazyWriterContext
	)

Definition at line 1286 of file view.c.

{
    KIRQL OldIrql;
    BOOLEAN Allocated;
    PROS_SHARED_CACHE_MAP SharedCacheMap;
 
    DPRINT("CcRosInitializeFileCache(FileObject 0x%p)\n", FileObject);
 
    OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
 
    Allocated = FALSE;
    SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
    if (SharedCacheMap == NULL)
    {
        SharedCacheMap = ExAllocateFromNPagedLookasideList(&SharedCacheMapLookasideList);
        if (SharedCacheMap == NULL)
        {
            KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        RtlZeroMemory(SharedCacheMap, sizeof(*SharedCacheMap));
        SharedCacheMap->NodeTypeCode = NODE_TYPE_SHARED_MAP;
        SharedCacheMap->NodeByteSize = sizeof(*SharedCacheMap);
        SharedCacheMap->FileObject = FileObject;
        SharedCacheMap->Callbacks = CallBacks;
        SharedCacheMap->LazyWriteContext = LazyWriterContext;
        SharedCacheMap->SectionSize = FileSizes->AllocationSize;
        SharedCacheMap->FileSize = FileSizes->FileSize;
        SharedCacheMap->ValidDataLength = FileSizes->ValidDataLength;
        SharedCacheMap->PinAccess = PinAccess;
        SharedCacheMap->DirtyPageThreshold = 0;
        SharedCacheMap->DirtyPages = 0;
        InitializeListHead(&SharedCacheMap->PrivateList);
        KeInitializeSpinLock(&SharedCacheMap->CacheMapLock);
        InitializeListHead(&SharedCacheMap->CacheMapVacbListHead);
        InitializeListHead(&SharedCacheMap->BcbList);
        KeInitializeGuardedMutex(&SharedCacheMap->FlushCacheLock);
 
        SharedCacheMap->Flags = SHARED_CACHE_MAP_IN_CREATION;
 
        ObReferenceObjectByPointer(FileObject,
                                   FILE_ALL_ACCESS,
                                   NULL,
                                   KernelMode);
 
        Allocated = TRUE;
        FileObject->SectionObjectPointer->SharedCacheMap = SharedCacheMap;
 
        //CcRosTraceCacheMap(SharedCacheMap, TRUE);
    }
    else if (SharedCacheMap->Flags & SHARED_CACHE_MAP_IN_CREATION)
    {
        /* The shared cache map is being created somewhere else. Wait for that to happen */
        KEVENT Waiter;
        PKEVENT PreviousWaiter = SharedCacheMap->CreateEvent;
 
        KeInitializeEvent(&Waiter, NotificationEvent, FALSE);
        SharedCacheMap->CreateEvent = &Waiter;
 
        KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
 
        KeWaitForSingleObject(&Waiter, Executive, KernelMode, FALSE, NULL);
 
        if (PreviousWaiter)
            KeSetEvent(PreviousWaiter, IO_NO_INCREMENT, FALSE);
 
        OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
    }
 
    if (FileObject->PrivateCacheMap == NULL)
    {
        PPRIVATE_CACHE_MAP PrivateMap;
 
        /* Allocate the private cache map for this handle */
        if (SharedCacheMap->PrivateCacheMap.NodeTypeCode != 0)
        {
            PrivateMap = ExAllocatePoolWithTag(NonPagedPool, sizeof(PRIVATE_CACHE_MAP), TAG_PRIVATE_CACHE_MAP);
        }
        else
        {
            PrivateMap = &SharedCacheMap->PrivateCacheMap;
        }
 
        if (PrivateMap == NULL)
        {
            /* If we also allocated the shared cache map for this file, kill it */
            if (Allocated)
            {
                RemoveEntryList(&SharedCacheMap->SharedCacheMapLinks);
 
                FileObject->SectionObjectPointer->SharedCacheMap = NULL;
                ObDereferenceObject(FileObject);
                ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap);
            }
 
            KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        /* Initialize it */
        RtlZeroMemory(PrivateMap, sizeof(PRIVATE_CACHE_MAP));
        PrivateMap->NodeTypeCode = NODE_TYPE_PRIVATE_MAP;
        PrivateMap->ReadAheadMask = PAGE_SIZE - 1;
        PrivateMap->FileObject = FileObject;
        KeInitializeSpinLock(&PrivateMap->ReadAheadSpinLock);
 
        /* Link it to the file */
        KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
        InsertTailList(&SharedCacheMap->PrivateList, &PrivateMap->PrivateLinks);
        KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
 
        FileObject->PrivateCacheMap = PrivateMap;
        SharedCacheMap->OpenCount++;
    }
 
    KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
 
    /* Create the section */
    if (Allocated)
    {
        NTSTATUS Status;
 
        ASSERT(SharedCacheMap->Section == NULL);
 
        Status = MmCreateSection(
            &SharedCacheMap->Section,
            SECTION_ALL_ACCESS,
            NULL,
            &SharedCacheMap->SectionSize,
            PAGE_READWRITE,
            SEC_RESERVE,
            NULL,
            FileObject);
 
        ASSERT(NT_SUCCESS(Status));
 
        if (!NT_SUCCESS(Status))
        {
            CcRosReleaseFileCache(FileObject);
            return Status;
        }
 
        OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
 
        InsertTailList(&CcCleanSharedCacheMapList, &SharedCacheMap->SharedCacheMapLinks);
        SharedCacheMap->Flags &= ~SHARED_CACHE_MAP_IN_CREATION;
 
        if (SharedCacheMap->CreateEvent)
        {
            KeSetEvent(SharedCacheMap->CreateEvent, IO_NO_INCREMENT, FALSE);
            SharedCacheMap->CreateEvent = NULL;
        }
 
        KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
    }
 
    return STATUS_SUCCESS;
}

Referenced by CcInitializeCacheMap().

CcRosInternalFreeVacb()

NTSTATUS CcRosInternalFreeVacb

(

IN PROS_VACB

Vacb

)

Referenced by CcRosVacbDecRefCount().

CcRosLookupVacb()

PROS_VACB CcRosLookupVacb	(	PROS_SHARED_CACHE_MAP	SharedCacheMap,
		LONGLONG	FileOffset
	)

Definition at line 624 of file view.c.

{
    PLIST_ENTRY current_entry;
    PROS_VACB current;
    KIRQL oldIrql;
 
    ASSERT(SharedCacheMap);
 
    DPRINT("CcRosLookupVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
           SharedCacheMap, FileOffset);
 
    oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
    KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
 
    current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
    while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
    {
        current = CONTAINING_RECORD(current_entry,
                                    ROS_VACB,
                                    CacheMapVacbListEntry);
        if (IsPointInRange(current->FileOffset.QuadPart,
                           VACB_MAPPING_GRANULARITY,
                           FileOffset))
        {
            CcRosVacbIncRefCount(current);
            KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
            KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
            return current;
        }
        if (current->FileOffset.QuadPart > FileOffset)
            break;
        current_entry = current_entry->Flink;
    }
 
    KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
    KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
 
    return NULL;
}

Referenced by CcFlushCache(), and CcRosGetVacb().

CcRosMarkDirtyVacb()

VOID CcRosMarkDirtyVacb

(

PROS_VACB

Vacb

)

Definition at line 667 of file view.c.

{
    KIRQL oldIrql;
    PROS_SHARED_CACHE_MAP SharedCacheMap;
 
    SharedCacheMap = Vacb->SharedCacheMap;
 
    oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
    KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
 
    ASSERT(!Vacb->Dirty);
 
    InsertTailList(&DirtyVacbListHead, &Vacb->DirtyVacbListEntry);
    /* FIXME: There is no reason to account for the whole VACB. */
    CcTotalDirtyPages += VACB_MAPPING_GRANULARITY / PAGE_SIZE;
    Vacb->SharedCacheMap->DirtyPages += VACB_MAPPING_GRANULARITY / PAGE_SIZE;
    CcRosVacbIncRefCount(Vacb);
 
    /* Move to the tail of the LRU list */
    RemoveEntryList(&Vacb->VacbLruListEntry);
    InsertTailList(&VacbLruListHead, &Vacb->VacbLruListEntry);
 
    Vacb->Dirty = TRUE;
 
    KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
 
    /* Schedule a lazy writer run to now that we have dirty VACB */
    if (!LazyWriter.ScanActive)
    {
        CcScheduleLazyWriteScan(FALSE);
    }
    KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
}

Referenced by CcRosFlushVacb(), CcRosReleaseVacb(), and CcSetDirtyPinnedData().

CcRosReferenceCache()

VOID CcRosReferenceCache

(

PFILE_OBJECT

FileObject

)

CcRosReleaseFileCache()

NTSTATUS CcRosReleaseFileCache

(

PFILE_OBJECT

FileObject

)

Definition at line 1230 of file view.c.

{
    KIRQL OldIrql;
    PPRIVATE_CACHE_MAP PrivateMap;
    PROS_SHARED_CACHE_MAP SharedCacheMap;
 
    OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
 
    if (FileObject->SectionObjectPointer->SharedCacheMap != NULL)
    {
        SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
 
        /* Closing the handle, so kill the private cache map
         * Before you event try to remove it from FO, always
         * lock the master lock, to be sure not to race
         * with a potential read ahead ongoing!
         */
        PrivateMap = FileObject->PrivateCacheMap;
        FileObject->PrivateCacheMap = NULL;
 
        if (PrivateMap != NULL)
        {
            /* Remove it from the file */
            KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
            RemoveEntryList(&PrivateMap->PrivateLinks);
            KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
 
            /* And free it. */
            if (PrivateMap != &SharedCacheMap->PrivateCacheMap)
            {
                ExFreePoolWithTag(PrivateMap, TAG_PRIVATE_CACHE_MAP);
            }
            else
            {
                PrivateMap->NodeTypeCode = 0;
            }
 
            ASSERT(SharedCacheMap->OpenCount > 0);
 
            SharedCacheMap->OpenCount--;
            if (SharedCacheMap->OpenCount == 0)
            {
                CcRosDeleteFileCache(FileObject, SharedCacheMap, &OldIrql);
            }
        }
    }
    KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
    return STATUS_SUCCESS;
}

Referenced by CcRosInitializeFileCache(), and CcUninitializeCacheMap().

CcRosReleaseVacb()

NTSTATUS CcRosReleaseVacb	(	PROS_SHARED_CACHE_MAP	SharedCacheMap,
		PROS_VACB	Vacb,
		BOOLEAN	Dirty,
		BOOLEAN	Mapped
	)

Definition at line 592 of file view.c.

{
    ULONG Refs;
    ASSERT(SharedCacheMap);
 
    DPRINT("CcRosReleaseVacb(SharedCacheMap 0x%p, Vacb 0x%p)\n", SharedCacheMap, Vacb);
 
    if (Dirty && !Vacb->Dirty)
    {
        CcRosMarkDirtyVacb(Vacb);
    }
 
    if (Mapped)
    {
        if (InterlockedIncrement((PLONG)&Vacb->MappedCount) == 1)
        {
            CcRosVacbIncRefCount(Vacb);
        }
    }
 
    Refs = CcRosVacbDecRefCount(Vacb);
    ASSERT(Refs > 0);
 
    return STATUS_SUCCESS;
}

Referenced by CcCopyRead(), CcCopyWrite(), CcFlushCache(), CcMapData(), CcpDereferenceBcb(), CcPerformReadAhead(), CcpGetAppropriateBcb(), CcpPinData(), CcUnpinRepinnedBcb(), and CcZeroData().

CcRosRequestVacb()

NTSTATUS CcRosRequestVacb	(	PROS_SHARED_CACHE_MAP	SharedCacheMap,
		LONGLONG	FileOffset,
		PROS_VACB *	Vacb
	)

Definition at line 1029 of file view.c.

{
 
    ASSERT(SharedCacheMap);
 
    if (FileOffset % VACB_MAPPING_GRANULARITY != 0)
    {
        DPRINT1("Bad FileOffset %I64x: should be multiple of %x\n",
                FileOffset, VACB_MAPPING_GRANULARITY);
        KeBugCheck(CACHE_MANAGER);
    }
 
    return CcRosGetVacb(SharedCacheMap,
                        FileOffset,
                        Vacb);
}

Referenced by CcPerformReadAhead().

CcRosUnmarkDirtyVacb()

VOID CcRosUnmarkDirtyVacb	(	PROS_VACB	Vacb,
		BOOLEAN	LockViews
	)

Definition at line 703 of file view.c.

{
    KIRQL oldIrql;
    PROS_SHARED_CACHE_MAP SharedCacheMap;
 
    SharedCacheMap = Vacb->SharedCacheMap;
 
    if (LockViews)
    {
        oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
        KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
    }
 
    ASSERT(Vacb->Dirty);
 
    Vacb->Dirty = FALSE;
 
    RemoveEntryList(&Vacb->DirtyVacbListEntry);
    InitializeListHead(&Vacb->DirtyVacbListEntry);
 
    CcTotalDirtyPages -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
    Vacb->SharedCacheMap->DirtyPages -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
 
    CcRosVacbDecRefCount(Vacb);
 
    if (LockViews)
    {
        KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
        KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
    }
}

Referenced by CcPurgeCacheSection(), CcRosDeleteFileCache(), and CcRosFlushVacb().

CcRosVacbDecRefCount()

FORCEINLINE ULONG CcRosVacbDecRefCount

(

PROS_VACB

vacb

)

Definition at line 499 of file cc.h.

{
    ULONG Refs;
 
    Refs = InterlockedDecrement((PLONG)&vacb->ReferenceCount);
    if (Refs == 0)
    {
        CcRosInternalFreeVacb(vacb);
    }
    return Refs;
}

Referenced by CcPurgeCacheSection(), CcRosCreateVacb(), CcRosDeleteFileCache(), CcRosFlushDirtyPages(), CcRosFreeOneUnusedVacb(), CcRosReleaseVacb(), CcRosTrimCache(), and CcRosUnmarkDirtyVacb().

CcScanDpc()

VOID NTAPI CcScanDpc	(	PKDPC	Dpc,
		PVOID	DeferredContext,
		PVOID	SystemArgument1,
		PVOID	SystemArgument2
	)

CcScheduleLazyWriteScan()

VOID CcScheduleLazyWriteScan

(

BOOLEAN

NoDelay

)

CcShutdownLazyWriter()

VOID NTAPI CcShutdownLazyWriter

(

VOID

)

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

Referenced by PopGracefulShutdown().

CcWorkerThread()

VOID NTAPI CcWorkerThread

(

PVOID

Parameter

)

DoRangesIntersect()

FORCEINLINE BOOLEAN DoRangesIntersect	(	_In_ LONGLONG	Offset1,
		_In_ LONGLONG	Length1,
		_In_ LONGLONG	Offset2,
		_In_ LONGLONG	Length2
	)

Definition at line 447 of file cc.h.

{
    if (Offset1 + Length1 <= Offset2)
        return FALSE;
    if (Offset2 + Length2 <= Offset1)
        return FALSE;
    return TRUE;
}

Referenced by IsPointInRange().

IsPointInRange()

FORCEINLINE BOOLEAN IsPointInRange	(	_In_ LONGLONG	Offset1,
		_In_ LONGLONG	Length1,
		_In_ LONGLONG	Point
	)

Definition at line 462 of file cc.h.

{
    return DoRangesIntersect(Offset1, Length1, Point, 1);
}

Referenced by CcRosCreateVacb(), and CcRosLookupVacb().

Variable Documentation

CcDataFlushes

ULONG CcDataFlushes

extern

Definition at line 44 of file copy.c.

Referenced by IoSynchronousPageWrite(), and QSI_DEF().

CcDataPages

ULONG CcDataPages

extern

Definition at line 43 of file copy.c.

Referenced by IoSynchronousPageWrite(), and QSI_DEF().

CcDeferredWrites

LIST_ENTRY CcDeferredWrites

extern

Definition at line 58 of file view.c.

Referenced by CcCanIWrite(), CcDeferWrite(), CcInitView(), CcLazyWriteScan(), CcPostDeferredWrites(), and CcWorkerThread().

CcDeferredWriteSpinLock

KSPIN_LOCK CcDeferredWriteSpinLock

extern

Definition at line 59 of file view.c.

Referenced by CcCanIWrite(), CcDeferWrite(), CcInitView(), and CcPostDeferredWrites().

CcDirtyPageThreshold

ULONG CcDirtyPageThreshold

extern

Definition at line 56 of file view.c.

Referenced by CcCanIWrite(), and CcInitializeCacheManager().

CcExpressWorkQueue

LIST_ENTRY CcExpressWorkQueue

extern

Definition at line 39 of file lazywrite.c.

Referenced by CcInitializeCacheManager(), CcScheduleReadAhead(), and CcWorkerThread().

CcIdleDelay

LARGE_INTEGER CcIdleDelay

extern

Definition at line 46 of file lazywrite.c.

Referenced by CcCanIWrite(), and CcScheduleLazyWriteScan().

CcIdleWorkerThreadList

LIST_ENTRY CcIdleWorkerThreadList

extern

Definition at line 41 of file lazywrite.c.

Referenced by CcInitializeCacheManager(), CcPostWorkQueue(), and CcWorkerThread().

CcLazyWriteIos

ULONG CcLazyWriteIos

extern

Definition at line 21 of file lazywrite.c.

Referenced by CcWriteBehind(), and QSI_DEF().

CcLazyWritePages

ULONG CcLazyWritePages

extern

Definition at line 20 of file lazywrite.c.

Referenced by CcWriteBehind(), and QSI_DEF().

CcMapDataNoWait

ULONG CcMapDataNoWait

extern

Definition at line 29 of file pin.c.

Referenced by CcMapData(), and QSI_DEF().

CcMapDataWait

ULONG CcMapDataWait

extern

Definition at line 28 of file pin.c.

Referenced by CcMapData(), and QSI_DEF().

CcNumberWorkerThreads

ULONG CcNumberWorkerThreads

extern

Definition at line 48 of file lazywrite.c.

Referenced by CcInitializeCacheManager().

CcPinMappedDataCount

ULONG CcPinMappedDataCount

extern

Definition at line 32 of file pin.c.

Referenced by CcPinMappedData(), and QSI_DEF().

CcPinReadNoWait

ULONG CcPinReadNoWait

extern

Definition at line 31 of file pin.c.

Referenced by CcPinRead(), and QSI_DEF().

CcPinReadWait

ULONG CcPinReadWait

extern

Definition at line 30 of file pin.c.

Referenced by CcPinRead(), and QSI_DEF().

CcPostTickWorkQueue

LIST_ENTRY CcPostTickWorkQueue

extern

Definition at line 42 of file lazywrite.c.

Referenced by CcInitializeCacheManager(), CcLazyWriteScan(), and CcWaitForCurrentLazyWriterActivity().

CcRegularWorkQueue

LIST_ENTRY CcRegularWorkQueue

extern

Definition at line 40 of file lazywrite.c.

Referenced by CcInitializeCacheManager(), CcLazyWriteScan(), CcScanDpc(), and CcWorkerThread().

CcRosTraceLevel

ULONG CcRosTraceLevel

extern

Definition at line 31 of file copy.c.

CcTotalDirtyPages

ULONG CcTotalDirtyPages

extern

Definition at line 57 of file view.c.

Referenced by CcCanIWrite(), CcLazyWriteScan(), CcRosMarkDirtyVacb(), CcRosUnmarkDirtyVacb(), CcWorkerThread(), and CcWriteBehind().

CcTwilightLookasideList

NPAGED_LOOKASIDE_LIST CcTwilightLookasideList

extern

Definition at line 38 of file lazywrite.c.

Referenced by CcInitializeCacheManager(), CcLazyWriteScan(), CcScanDpc(), CcScheduleReadAhead(), CcWaitForCurrentLazyWriterActivity(), and CcWorkerThread().

DirtyVacbListHead

LIST_ENTRY DirtyVacbListHead

extern

Definition at line 42 of file view.c.

Referenced by CcInitView(), CcIsThereDirtyData(), CcRosFlushDirtyPages(), and CcRosMarkDirtyVacb().

LazyWriter

LAZY_WRITER LazyWriter

extern

Definition at line 37 of file lazywrite.c.

Referenced by CcDeferWrite(), CcInitializeCacheManager(), CcLazyWriteScan(), CcRosMarkDirtyVacb(), CcScanDpc(), CcScheduleLazyWriteScan(), and CcWaitForCurrentLazyWriterActivity().