ReactOS 0.4.16-dev-1109-gd06d9f3
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_IDPPF_SCENARIO_ID
 
typedef struct _PF_LOG_ENTRY PF_LOG_ENTRY
 
typedef struct _PF_LOG_ENTRYPPF_LOG_ENTRY
 
typedef struct _PFSN_LOG_ENTRIES PFSN_LOG_ENTRIES
 
typedef struct _PFSN_LOG_ENTRIESPPFSN_LOG_ENTRIES
 
typedef struct _PF_SECTION_INFO PF_SECTION_INFO
 
typedef struct _PF_SECTION_INFOPPF_SECTION_INFO
 
typedef struct _PF_TRACE_HEADER PF_TRACE_HEADER
 
typedef struct _PF_TRACE_HEADERPPF_TRACE_HEADER
 
typedef struct _PFSN_TRACE_DUMP PFSN_TRACE_DUMP
 
typedef struct _PFSN_TRACE_DUMPPPFSN_TRACE_DUMP
 
typedef struct _PFSN_TRACE_HEADER PFSN_TRACE_HEADER
 
typedef struct _PFSN_TRACE_HEADERPPFSN_TRACE_HEADER
 
typedef struct _PFSN_PREFETCHER_GLOBALS PFSN_PREFETCHER_GLOBALS
 
typedef struct _PFSN_PREFETCHER_GLOBALSPPFSN_PREFETCHER_GLOBALS
 
typedef struct _ROS_SHARED_CACHE_MAP ROS_SHARED_CACHE_MAP
 
typedef struct _ROS_SHARED_CACHE_MAPPROS_SHARED_CACHE_MAP
 
typedef struct _ROS_VACB ROS_VACB
 
typedef struct _ROS_VACBPROS_VACB
 
typedef struct _INTERNAL_BCB INTERNAL_BCB
 
typedef struct _INTERNAL_BCBPINTERNAL_BCB
 
typedef struct _LAZY_WRITER LAZY_WRITER
 
typedef struct _LAZY_WRITERPLAZY_WRITER
 
typedef struct _WORK_QUEUE_ENTRY WORK_QUEUE_ENTRY
 
typedef struct _WORK_QUEUE_ENTRYPWORK_QUEUE_ENTRY
 
typedef enum _WORK_QUEUE_FUNCTIONS WORK_QUEUE_FUNCTIONS
 
typedef enum _WORK_QUEUE_FUNCTIONSPWORK_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

◆ LAZY_WRITER

◆ PF_LOG_ENTRY

◆ PF_SCENARIO_ID

◆ PF_SECTION_INFO

◆ PF_TRACE_HEADER

◆ PFSN_LOG_ENTRIES

◆ PFSN_PREFETCHER_GLOBALS

◆ PFSN_TRACE_DUMP

◆ PFSN_TRACE_HEADER

◆ PINTERNAL_BCB

◆ PLAZY_WRITER

◆ PPF_LOG_ENTRY

◆ PPF_SCENARIO_ID

◆ PPF_SECTION_INFO

◆ PPF_TRACE_HEADER

◆ PPFSN_LOG_ENTRIES

◆ PPFSN_PREFETCHER_GLOBALS

◆ PPFSN_TRACE_DUMP

◆ PPFSN_TRACE_HEADER

◆ PROS_SHARED_CACHE_MAP

◆ PROS_VACB

◆ PWORK_QUEUE_ENTRY

◆ PWORK_QUEUE_FUNCTIONS

◆ ROS_SHARED_CACHE_MAP

◆ ROS_VACB

◆ WORK_QUEUE_ENTRY

◆ WORK_QUEUE_FUNCTIONS

Enumeration Type Documentation

◆ _WORK_QUEUE_FUNCTIONS

Enumerator
ReadAhead 
WriteBehind 
LazyScan 
SetDone 

Definition at line 277 of file cc.h.

278{
279 ReadAhead = 1,
280 WriteBehind = 2,
281 LazyScan = 3,
282 SetDone = 4,
enum _WORK_QUEUE_FUNCTIONS WORK_QUEUE_FUNCTIONS
enum _WORK_QUEUE_FUNCTIONS * PWORK_QUEUE_FUNCTIONS
@ SetDone
Definition: cc.h:282
@ LazyScan
Definition: cc.h:281
@ WriteBehind
Definition: cc.h:280
@ ReadAhead
Definition: cc.h:279

Function Documentation

◆ CcInitCacheZeroPage()

VOID NTAPI CcInitCacheZeroPage ( VOID  )

Definition at line 56 of file copy.c.

58{
60
62 //MI_SET_PROCESS2(PsGetCurrentProcess()->ImageFileName);
64 if (!NT_SUCCESS(Status))
65 {
66 DbgPrint("Can't allocate CcZeroPage.\n");
67 KeBugCheck(CACHE_MANAGER);
68 }
70}
LONG NTSTATUS
Definition: precomp.h:26
DECLSPEC_NORETURN VOID NTAPI KeBugCheck(ULONG BugCheckCode)
Definition: bug.c:1434
#define TRUE
Definition: types.h:120
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
Status
Definition: gdiplustypes.h:25
#define DbgPrint
Definition: hal.h:12
VOID NTAPI MiZeroPhysicalPage(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:122
static PFN_NUMBER CcZeroPage
Definition: copy.c:19
@ MI_USAGE_CACHE
Definition: mm.h:353
#define MC_SYSTEM
Definition: mm.h:115
#define MI_SET_USAGE(x)
Definition: mm.h:328
NTSTATUS NTAPI MmRequestPageMemoryConsumer(ULONG Consumer, BOOLEAN MyWait, PPFN_NUMBER AllocatedPage)
Definition: balance.c:313

◆ CcInitializeCacheManager()

BOOLEAN CcInitializeCacheManager ( VOID  )

Definition at line 83 of file fssup.c.

84{
85 int i;
86
87 DPRINT("Initialize\n");
88 for (i = 0; i < CACHE_NUM_SECTIONS; i++)
89 {
90 KeInitializeEvent(&CcCacheSections[i].ExclusiveWait,
92 FALSE);
93
94 InitializeListHead(&CcCacheSections[i].ThisFileList);
95 }
96
98
102
105 DPRINT1("Cache has %d entries\n", CcCacheBitmap->SizeOfBitMap);
107
108 return TRUE;
109}
#define DPRINT1
Definition: precomp.h:8
#define FALSE
Definition: types.h:117
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define ROUND_UP(n, align)
Definition: eventvwr.h:34
KEVENT CcpLazyWriteEvent
Definition: lazyrite.c:18
KEVENT CcFinalizeEvent
Definition: pinsup.c:103
LIST_ENTRY CcpAllSharedCacheMaps
Definition: fssup.c:76
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
FAST_MUTEX CcMutex
Definition: pinsup.c:101
NOCC_BCB CcCacheSections[CACHE_NUM_SECTIONS]
Definition: pinsup.c:98
PRTL_BITMAP CcCacheBitmap
Definition: pinsup.c:100
KEVENT CcDeleteEvent
Definition: pinsup.c:102
#define CACHE_NUM_SECTIONS
Definition: newcc.h:125
@ SynchronizationEvent
#define DPRINT
Definition: sndvol32.h:73
ULONG SizeOfBitMap
Definition: typedefs.h:90
PULONG Buffer
Definition: typedefs.h:91
uint32_t * PULONG
Definition: typedefs.h:59
FORCEINLINE VOID ExInitializeFastMutex(_Out_ PFAST_MUTEX FastMutex)
Definition: exfuncs.h:274

Referenced by Phase1InitializationDiscard().

◆ CcInitView()

VOID NTAPI CcInitView ( VOID  )

Definition at line 1477 of file view.c.

1479{
1480 DPRINT("CcInitView()\n");
1481
1488 NULL,
1489 NULL,
1490 0,
1491 sizeof(INTERNAL_BCB),
1492 TAG_BCB,
1493 20);
1495 NULL,
1496 NULL,
1497 0,
1498 sizeof(ROS_SHARED_CACHE_MAP),
1500 20);
1502 NULL,
1503 NULL,
1504 0,
1505 sizeof(ROS_VACB),
1506 TAG_VACB,
1507 20);
1508
1510}
#define NULL
Definition: types.h:112
#define TAG_BCB
Definition: nodetype.h:157
#define KeInitializeSpinLock(sl)
Definition: env_spec_w32.h:604
VOID NTAPI ExInitializeNPagedLookasideList(IN PNPAGED_LOOKASIDE_LIST Lookaside, IN PALLOCATE_FUNCTION Allocate OPTIONAL, IN PFREE_FUNCTION Free OPTIONAL, IN ULONG Flags, IN SIZE_T Size, IN ULONG Tag, IN USHORT Depth)
Definition: lookas.c:218
VOID NTAPI CcInitCacheZeroPage(VOID)
Definition: copy.c:56
LIST_ENTRY CcCleanSharedCacheMapList
Definition: view.c:60
static LIST_ENTRY VacbLruListHead
Definition: view.c:43
KSPIN_LOCK CcDeferredWriteSpinLock
Definition: view.c:59
LIST_ENTRY CcDeferredWrites
Definition: view.c:58
NPAGED_LOOKASIDE_LIST iBcbLookasideList
Definition: view.c:45
LIST_ENTRY DirtyVacbListHead
Definition: view.c:42
static NPAGED_LOOKASIDE_LIST SharedCacheMapLookasideList
Definition: view.c:46
static NPAGED_LOOKASIDE_LIST VacbLookasideList
Definition: view.c:47
Definition: cc.h:208
#define TAG_SHARED_CACHE_MAP
Definition: tag.h:16
#define TAG_VACB
Definition: tag.h:15

◆ CcMdlReadComplete2()

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

Definition at line 83 of file mdlsup.c.

85{
87}
#define UNIMPLEMENTED
Definition: ntoskrnl.c:15

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.

114{
116}

Referenced by CcMdlWriteComplete(), and FsRtlMdlWriteCompleteDev().

◆ CcPerformReadAhead()

VOID CcPerformReadAhead ( IN PFILE_OBJECT  FileObject)

Definition at line 130 of file copy.c.

132{
134 LONGLONG CurrentOffset;
136 PROS_SHARED_CACHE_MAP SharedCacheMap;
137 PROS_VACB Vacb;
138 ULONG PartialLength;
140 PPRIVATE_CACHE_MAP PrivateCacheMap;
143
144 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
145
146 /* Critical:
147 * PrivateCacheMap might disappear in-between if the handle
148 * to the file is closed (private is attached to the handle not to
149 * the file), so we need to lock the master lock while we deal with
150 * it. It won't disappear without attempting to lock such lock.
151 */
153 PrivateCacheMap = FileObject->PrivateCacheMap;
154 /* If the handle was closed since the read ahead was scheduled, just quit */
155 if (PrivateCacheMap == NULL)
156 {
159 return;
160 }
161 /* Otherwise, extract read offset and length and release private map */
162 else
163 {
165 CurrentOffset = PrivateCacheMap->ReadAheadOffset[1].QuadPart;
166 Length = PrivateCacheMap->ReadAheadLength[1];
168 }
170
171 /* Time to go! */
172 DPRINT("Doing ReadAhead for %p\n", FileObject);
173 /* Lock the file, first */
174 if (!SharedCacheMap->Callbacks->AcquireForReadAhead(SharedCacheMap->LazyWriteContext, FALSE))
175 {
176 Locked = FALSE;
177 goto Clear;
178 }
179
180 /* Remember it's locked */
181 Locked = TRUE;
182
183 /* Don't read past the end of the file */
184 if (CurrentOffset >= SharedCacheMap->FileSize.QuadPart)
185 {
186 goto Clear;
187 }
188 if (CurrentOffset + Length > SharedCacheMap->FileSize.QuadPart)
189 {
190 Length = SharedCacheMap->FileSize.QuadPart - CurrentOffset;
191 }
192
193 /* Next of the algorithm will lock like CcCopyData with the slight
194 * difference that we don't copy data back to an user-backed buffer
195 * We just bring data into Cc
196 */
197 PartialLength = CurrentOffset % VACB_MAPPING_GRANULARITY;
198 if (PartialLength != 0)
199 {
200 PartialLength = min(Length, VACB_MAPPING_GRANULARITY - PartialLength);
201 Status = CcRosRequestVacb(SharedCacheMap,
202 ROUND_DOWN(CurrentOffset, VACB_MAPPING_GRANULARITY),
203 &Vacb);
204 if (!NT_SUCCESS(Status))
205 {
206 DPRINT1("Failed to request VACB: %lx!\n", Status);
207 goto Clear;
208 }
209
211 {
213 CurrentOffset % VACB_MAPPING_GRANULARITY, PartialLength);
214 }
216 {
217 Success = FALSE;
218 }
220
221 if (!Success)
222 {
223 CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
224 DPRINT1("Failed to read data: %lx!\n", Status);
225 goto Clear;
226 }
227
228 CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
229
230 Length -= PartialLength;
231 CurrentOffset += PartialLength;
232 }
233
234 while (Length > 0)
235 {
236 ASSERT(CurrentOffset % VACB_MAPPING_GRANULARITY == 0);
237 PartialLength = min(VACB_MAPPING_GRANULARITY, Length);
238 Status = CcRosRequestVacb(SharedCacheMap,
239 CurrentOffset,
240 &Vacb);
241 if (!NT_SUCCESS(Status))
242 {
243 DPRINT1("Failed to request VACB: %lx!\n", Status);
244 goto Clear;
245 }
246
248 {
249 Success = CcRosEnsureVacbResident(Vacb, TRUE, FALSE, 0, PartialLength);
250 }
252 {
253 Success = FALSE;
254 }
256
257 if (!Success)
258 {
259 CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
260 DPRINT1("Failed to read data: %lx!\n", Status);
261 goto Clear;
262 }
263
264 CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
265
266 Length -= PartialLength;
267 CurrentOffset += PartialLength;
268 }
269
270Clear:
271 /* See previous comment about private cache map */
273 PrivateCacheMap = FileObject->PrivateCacheMap;
274 if (PrivateCacheMap != NULL)
275 {
276 /* Mark read ahead as unactive */
278 InterlockedAnd((volatile long *)&PrivateCacheMap->UlongFlags, ~PRIVATE_CACHE_MAP_READ_AHEAD_ACTIVE);
280 }
282
283 /* If file was locked, release it */
284 if (Locked)
285 {
286 SharedCacheMap->Callbacks->ReleaseFromReadAhead(SharedCacheMap->LazyWriteContext);
287 }
288
289 /* And drop our extra reference (See: CcScheduleReadAhead) */
291
292 return;
293}
unsigned char BOOLEAN
UCHAR KIRQL
Definition: env_spec_w32.h:591
@ Success
Definition: eventcreate.c:712
#define ROUND_DOWN(n, align)
Definition: eventvwr.h:33
VOID FASTCALL KeReleaseQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber, IN KIRQL OldIrql)
Definition: spinlock.c:154
KIRQL FASTCALL KeAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
Definition: spinlock.c:108
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
#define InterlockedAnd
Definition: interlocked.h:62
#define ASSERT(a)
Definition: mode.c:44
static void Clear(void)
Definition: treeview.c:388
#define min(a, b)
Definition: monoChain.cc:55
#define PRIVATE_CACHE_MAP_READ_AHEAD_ACTIVE
Definition: cctypes.h:64
_In_ PMEMORY_AREA _In_ PVOID _In_ BOOLEAN Locked
Definition: newmm.h:209
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
NTSTATUS CcRosReleaseVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, PROS_VACB Vacb, BOOLEAN Dirty, BOOLEAN Mapped)
Definition: view.c:592
NTSTATUS CcRosRequestVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset, PROS_VACB *Vacb)
Definition: view.c:1029
BOOLEAN CcRosEnsureVacbResident(_In_ PROS_VACB Vacb, _In_ BOOLEAN Wait, _In_ BOOLEAN NoRead, _In_ ULONG Offset, _In_ ULONG Length)
Definition: view.c:932
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:82
#define _SEH2_END
Definition: pseh2_64.h:171
#define _SEH2_TRY
Definition: pseh2_64.h:71
#define KeAcquireSpinLockAtDpcLevel(SpinLock)
Definition: ke.h:125
#define KeReleaseSpinLockFromDpcLevel(SpinLock)
Definition: ke.h:135
PACQUIRE_FOR_READ_AHEAD AcquireForReadAhead
Definition: cctypes.h:41
PRELEASE_FROM_READ_AHEAD ReleaseFromReadAhead
Definition: cctypes.h:42
ULONG ReadAheadLength[2]
Definition: cctypes.h:82
LARGE_INTEGER ReadAheadOffset[2]
Definition: cctypes.h:81
KSPIN_LOCK ReadAheadSpinLock
Definition: cctypes.h:83
ULONG UlongFlags
Definition: cctypes.h:73
LARGE_INTEGER FileSize
Definition: cc.h:175
PCACHE_MANAGER_CALLBACKS Callbacks
Definition: cc.h:185
PVOID LazyWriteContext
Definition: cc.h:186
int64_t LONGLONG
Definition: typedefs.h:68
uint32_t ULONG
Definition: typedefs.h:59
LONGLONG QuadPart
Definition: typedefs.h:114
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:550
#define VACB_MAPPING_GRANULARITY
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778
@ LockQueueMasterLock
Definition: ketypes.h:663
#define ObDereferenceObject
Definition: obfuncs.h:203

Referenced by CcWorkerThread().

◆ CcPfInitializePrefetcher()

VOID NTAPI CcPfInitializePrefetcher ( VOID  )

Definition at line 114 of file fssup.c.

115{
116 /* Notify debugger */
119 "CCPF: InitializePrefetecher()\n");
120
121 /* Setup the Prefetcher Data */
125
126 /* FIXME: Setup the rest of the prefetecher */
127}
@ DPFLTR_PREFETCHER_ID
Definition: dpfilter.h:91
PFSN_PREFETCHER_GLOBALS CcPfGlobals
Definition: fssup.c:20
#define DbgPrintEx(cmpid, lvl, fmt,...)
Definition: kdinit.c:24
#define DPFLTR_TRACE_LEVEL
Definition: kdtypes.h:32
LIST_ENTRY ActiveTraces
Definition: cc.h:160
LIST_ENTRY CompletedTraces
Definition: cc.h:163
FAST_MUTEX CompletedTracesLock
Definition: cc.h:164

Referenced by Phase1InitializationDiscard().

◆ CcPostDeferredWrites()

VOID CcPostDeferredWrites ( VOID  )

Definition at line 73 of file copy.c.

74{
75 LIST_ENTRY ToInsertBack;
76
77 InitializeListHead(&ToInsertBack);
78
79 /* We'll try to write as much as we can */
80 while (TRUE)
81 {
82 PDEFERRED_WRITE DeferredWrite;
83 PLIST_ENTRY ListEntry;
84
85 DeferredWrite = NULL;
86
88
89 if (!ListEntry)
90 break;
91
92 DeferredWrite = CONTAINING_RECORD(ListEntry, DEFERRED_WRITE, DeferredWriteLinks);
93
94 /* Check if we can write */
95 if (CcCanIWrite(DeferredWrite->FileObject, DeferredWrite->BytesToWrite, FALSE, RetryForceCheckPerFile))
96 {
97 /* If we have an event, set it and go along */
98 if (DeferredWrite->Event)
99 {
100 KeSetEvent(DeferredWrite->Event, IO_NO_INCREMENT, FALSE);
101 }
102 /* Otherwise, call the write routine and free the context */
103 else
104 {
105 DeferredWrite->PostRoutine(DeferredWrite->Context1, DeferredWrite->Context2);
106 ExFreePoolWithTag(DeferredWrite, 'CcDw');
107 }
108 continue;
109 }
110
111 /* Keep it for later */
112 InsertHeadList(&ToInsertBack, &DeferredWrite->DeferredWriteLinks);
113
114 /* If we don't accept modified pages, stop here */
115 if (!DeferredWrite->LimitModifiedPages)
116 {
117 break;
118 }
119 }
120
121 /* Insert what we couldn't write back in the list */
122 while (!IsListEmpty(&ToInsertBack))
123 {
124 PLIST_ENTRY ListEntry = RemoveTailList(&ToInsertBack);
126 }
127}
#define InsertHeadList(ListHead, Entry)
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
#define RemoveTailList(ListHead)
Definition: env_spec_w32.h:975
PLIST_ENTRY NTAPI ExInterlockedInsertHeadList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:114
PLIST_ENTRY NTAPI ExInterlockedRemoveHeadList(IN OUT PLIST_ENTRY ListHead, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:166
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
BOOLEAN NTAPI CcCanIWrite(IN PFILE_OBJECT FileObject, IN ULONG BytesToWrite, IN BOOLEAN Wait, IN BOOLEAN Retrying)
Definition: copy.c:300
@ RetryForceCheckPerFile
Definition: copy.c:27
PCC_POST_DEFERRED_WRITE PostRoutine
Definition: cctypes.h:175
PKEVENT Event
Definition: cctypes.h:174
ULONG BytesToWrite
Definition: cctypes.h:172
BOOLEAN LimitModifiedPages
Definition: cctypes.h:178
PVOID Context1
Definition: cctypes.h:176
PFILE_OBJECT FileObject
Definition: cctypes.h:171
PVOID Context2
Definition: cctypes.h:177
LIST_ENTRY DeferredWriteLinks
Definition: cctypes.h:173
Definition: typedefs.h:120
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
#define IO_NO_INCREMENT
Definition: iotypes.h:598

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.

56{
58 PWORK_QUEUE_ITEM ThreadToSpawn;
59
60 /* First of all, insert the item in the queue */
62 InsertTailList(WorkQueue, &WorkItem->WorkQueueLinks);
63
64 /* Now, define whether we have to spawn a new work thread
65 * We will spawn a new one if:
66 * - There's no throttle in action
67 * - There's still at least one idle thread
68 */
69 ThreadToSpawn = NULL;
71 {
72 PLIST_ENTRY ListEntry;
73
74 /* Get the idle thread */
76 ThreadToSpawn = CONTAINING_RECORD(ListEntry, WORK_QUEUE_ITEM, List);
77
78 /* We're going to have one more! */
80 }
81
83
84 /* If we have a thread to spawn, do it! */
85 if (ThreadToSpawn != NULL)
86 {
87 /* We NULLify it to be consistent with initialization */
88 ThreadToSpawn->List.Flink = NULL;
89 ExQueueWorkItem(ThreadToSpawn, CriticalWorkQueue);
90 }
91}
#define InsertTailList(ListHead, Entry)
#define RemoveHeadList(ListHead)
Definition: env_spec_w32.h:964
ULONG CcNumberActiveWorkerThreads
Definition: lazywrite.c:44
LIST_ENTRY CcIdleWorkerThreadList
Definition: lazywrite.c:41
BOOLEAN CcQueueThrottle
Definition: lazywrite.c:43
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
LIST_ENTRY List
Definition: extypes.h:203
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
_Must_inspect_result_ _In_ PWDF_WORKITEM_CONFIG _In_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWORKITEM * WorkItem
Definition: wdfworkitem.h:115
VOID NTAPI ExQueueWorkItem(IN PWORK_QUEUE_ITEM WorkItem, IN WORK_QUEUE_TYPE QueueType)
Definition: work.c:723
LIST_ENTRY WorkQueue
Definition: workqueue.c:16
@ CriticalWorkQueue
Definition: extypes.h:189
@ LockQueueWorkQueueLock
Definition: ketypes.h:666

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.

939{
940 PROS_SHARED_CACHE_MAP SharedCacheMap = Vacb->SharedCacheMap;
941
943
944#if 0
945 if ((Vacb->FileOffset.QuadPart + Offset) > SharedCacheMap->SectionSize.QuadPart)
946 {
947 DPRINT1("Vacb read beyond the file size!\n");
948 return FALSE;
949 }
950#endif
951
952 /* Check if the pages are resident */
953 if (!MmIsDataSectionResident(SharedCacheMap->FileObject->SectionObjectPointer,
954 Vacb->FileOffset.QuadPart + Offset,
955 Length))
956 {
957 if (!Wait)
958 {
959 return FALSE;
960 }
961
962 if (!NoRead)
963 {
964 NTSTATUS Status = MmMakeDataSectionResident(SharedCacheMap->FileObject->SectionObjectPointer,
965 Vacb->FileOffset.QuadPart + Offset,
966 Length,
967 &SharedCacheMap->ValidDataLength);
968 if (!NT_SUCCESS(Status))
970 }
971 }
972
973 return TRUE;
974}
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
BOOLEAN NTAPI MmIsDataSectionResident(_In_ PSECTION_OBJECT_POINTERS SectionObjectPointer, _In_ LONGLONG Offset, _In_ ULONG Length)
Definition: section.c:4939
NTSTATUS NTAPI MmMakeDataSectionResident(_In_ PSECTION_OBJECT_POINTERS SectionObjectPointer, _In_ LONGLONG Offset, _In_ ULONG Length, _In_ PLARGE_INTEGER ValidDataLength)
Definition: section.c:4981
#define ExRaiseStatus
Definition: ntoskrnl.h:114
LARGE_INTEGER ValidDataLength
Definition: cc.h:178
LARGE_INTEGER SectionSize
Definition: cc.h:177
PFILE_OBJECT FileObject
Definition: cc.h:179
_In_ WDFDPC _In_ BOOLEAN Wait
Definition: wdfdpc.h:170

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.

314{
315 PLIST_ENTRY current_entry;
318 BOOLEAN FlushAll = (Target == MAXULONG);
319
320 DPRINT("CcRosFlushDirtyPages(Target %lu)\n", Target);
321
322 (*Count) = 0;
323
326
327 current_entry = DirtyVacbListHead.Flink;
328 if (current_entry == &DirtyVacbListHead)
329 {
330 DPRINT("No Dirty pages\n");
331 }
332
333 while (((current_entry != &DirtyVacbListHead) && (Target > 0)) || FlushAll)
334 {
335 PROS_SHARED_CACHE_MAP SharedCacheMap;
338
339 if (current_entry == &DirtyVacbListHead)
340 {
341 ASSERT(FlushAll);
343 break;
344 current_entry = DirtyVacbListHead.Flink;
345 }
346
347 current = CONTAINING_RECORD(current_entry,
348 ROS_VACB,
349 DirtyVacbListEntry);
350 current_entry = current_entry->Flink;
351
353
354 SharedCacheMap = current->SharedCacheMap;
355
356 /* When performing lazy write, don't handle temporary files */
357 if (CalledFromLazy && BooleanFlagOn(SharedCacheMap->FileObject->Flags, FO_TEMPORARY_FILE))
358 {
360 continue;
361 }
362
363 /* Don't attempt to lazy write the files that asked not to */
364 if (CalledFromLazy && BooleanFlagOn(SharedCacheMap->Flags, WRITEBEHIND_DISABLED))
365 {
367 continue;
368 }
369
370 ASSERT(current->Dirty);
371
372 /* Do not lazy-write the same file concurrently. Fastfat ASSERTS on that */
373 if (SharedCacheMap->Flags & SHARED_CACHE_MAP_IN_LAZYWRITE)
374 {
376 continue;
377 }
378
379 SharedCacheMap->Flags |= SHARED_CACHE_MAP_IN_LAZYWRITE;
380
381 /* Keep a ref on the shared cache map */
382 SharedCacheMap->OpenCount++;
383
385
386 Locked = SharedCacheMap->Callbacks->AcquireForLazyWrite(SharedCacheMap->LazyWriteContext, Wait);
387 if (!Locked)
388 {
389 DPRINT("Not locked\n");
390 ASSERT(!Wait);
393 SharedCacheMap->Flags &= ~SHARED_CACHE_MAP_IN_LAZYWRITE;
394
395 if (--SharedCacheMap->OpenCount == 0)
396 CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap, &OldIrql);
397
398 continue;
399 }
400
403
404 SharedCacheMap->Callbacks->ReleaseFromLazyWrite(SharedCacheMap->LazyWriteContext);
405
406 /* We release the VACB before acquiring the lock again, because
407 * CcRosVacbDecRefCount might free the VACB, as CcRosFlushVacb dropped a
408 * Refcount. Freeing must be done outside of the lock.
409 * The refcount is decremented atomically. So this is OK. */
412
413 SharedCacheMap->Flags &= ~SHARED_CACHE_MAP_IN_LAZYWRITE;
414
415 if (--SharedCacheMap->OpenCount == 0)
416 CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap, &OldIrql);
417
420 {
421 DPRINT1("CC: Failed to flush VACB.\n");
422 }
423 else
424 {
425 ULONG PagesFreed;
426
427 /* How many pages did we free? */
428 PagesFreed = Iosb.Information / PAGE_SIZE;
429 (*Count) += PagesFreed;
430
431 if (!Wait)
432 {
433 /* Make sure we don't overflow target! */
434 if (Target < PagesFreed)
435 {
436 /* If we would have, jump to zero directly */
437 Target = 0;
438 }
439 else
440 {
441 Target -= PagesFreed;
442 }
443 }
444 }
445
446 current_entry = DirtyVacbListHead.Flink;
447 }
448
451
452 DPRINT("CcRosFlushDirtyPages() finished\n");
453 return STATUS_SUCCESS;
454}
return Iosb
Definition: create.c:4403
#define PAGE_SIZE
Definition: env_spec_w32.h:49
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
#define KeLeaveCriticalRegion()
Definition: ke_x.h:119
#define KeEnterCriticalRegion()
Definition: ke_x.h:88
struct task_struct * current
Definition: linux.c:32
static NTSTATUS CcRosDeleteFileCache(PFILE_OBJECT FileObject, PROS_SHARED_CACHE_MAP SharedCacheMap, PKIRQL OldIrql)
Definition: view.c:209
NTSTATUS CcRosFlushVacb(_In_ PROS_VACB Vacb, _Out_opt_ PIO_STATUS_BLOCK Iosb)
Definition: view.c:163
#define CcRosVacbIncRefCount(vacb)
Definition: cc.h:496
#define WRITEBEHIND_DISABLED
Definition: cc.h:203
#define SHARED_CACHE_MAP_IN_LAZYWRITE
Definition: cc.h:205
FORCEINLINE ULONG CcRosVacbDecRefCount(PROS_VACB vacb)
Definition: cc.h:499
#define STATUS_END_OF_FILE
Definition: shellext.h:67
#define STATUS_SUCCESS
Definition: shellext.h:65
PACQUIRE_FOR_LAZY_WRITE AcquireForLazyWrite
Definition: cctypes.h:39
PRELEASE_FROM_LAZY_WRITE ReleaseFromLazyWrite
Definition: cctypes.h:40
ULONG OpenCount
Definition: cc.h:174
#define MAXULONG
Definition: typedefs.h:251
#define STATUS_MEDIA_WRITE_PROTECTED
Definition: udferr_usr.h:161
_In_ WDFIOTARGET Target
Definition: wdfrequest.h:306
#define FO_TEMPORARY_FILE
Definition: iotypes.h:1791

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.

166{
168 BOOLEAN HaveLock = FALSE;
169 PROS_SHARED_CACHE_MAP SharedCacheMap = Vacb->SharedCacheMap;
170
172
173 /* Lock for flush, if we are not already the top-level */
175 {
176 Status = FsRtlAcquireFileForCcFlushEx(Vacb->SharedCacheMap->FileObject);
177 if (!NT_SUCCESS(Status))
178 goto quit;
179 HaveLock = TRUE;
180 }
181
182 Status = MmFlushSegment(SharedCacheMap->FileObject->SectionObjectPointer,
183 &Vacb->FileOffset,
185 Iosb);
186
187 if (HaveLock)
188 {
189 FsRtlReleaseFileForCcFlush(Vacb->SharedCacheMap->FileObject);
190 }
191
192quit:
193 if (!NT_SUCCESS(Status))
194 CcRosMarkDirtyVacb(Vacb);
195 else
196 {
197 /* Update VDL */
198 if (SharedCacheMap->ValidDataLength.QuadPart < (Vacb->FileOffset.QuadPart + VACB_MAPPING_GRANULARITY))
199 {
200 SharedCacheMap->ValidDataLength.QuadPart = Vacb->FileOffset.QuadPart + VACB_MAPPING_GRANULARITY;
201 }
202 }
203
204 return Status;
205}
void quit(int argc, const char *argv[])
Definition: cmds.c:1606
#define FSRTL_CACHE_TOP_LEVEL_IRP
Definition: fsrtltypes.h:60
VOID CcRosMarkDirtyVacb(PROS_VACB Vacb)
Definition: view.c:667
VOID CcRosUnmarkDirtyVacb(PROS_VACB Vacb, BOOLEAN LockViews)
Definition: view.c:703
NTSTATUS NTAPI FsRtlAcquireFileForCcFlushEx(IN PFILE_OBJECT FileObject)
Definition: fastio.c:1698
VOID NTAPI FsRtlReleaseFileForCcFlush(IN PFILE_OBJECT FileObject)
Definition: fastio.c:1771
NTSTATUS NTAPI MmFlushSegment(_In_ PSECTION_OBJECT_POINTERS SectionObjectPointer, _In_opt_ PLARGE_INTEGER Offset, _In_ ULONG Length, _Out_opt_ PIO_STATUS_BLOCK Iosb)
Definition: section.c:5058
PIRP NTAPI IoGetTopLevelIrp(VOID)
Definition: irp.c:1843

Referenced by CcFlushCache(), and CcRosFlushDirtyPages().

◆ CcRosFreeOneUnusedVacb()

BOOLEAN CcRosFreeOneUnusedVacb ( VOID  )

Definition at line 738 of file view.c.

740{
741 KIRQL oldIrql;
742 PLIST_ENTRY current_entry;
743 PROS_VACB to_free = NULL;
744
746
747 /* Browse all the available VACB */
748 current_entry = VacbLruListHead.Flink;
749 while ((current_entry != &VacbLruListHead) && (to_free == NULL))
750 {
751 ULONG Refs;
753
754 current = CONTAINING_RECORD(current_entry,
755 ROS_VACB,
756 VacbLruListEntry);
757
758 KeAcquireSpinLockAtDpcLevel(&current->SharedCacheMap->CacheMapLock);
759
760 /* Only deal with unused VACB, we will free them */
762 if (Refs < 2)
763 {
764 ASSERT(!current->Dirty);
765 ASSERT(!current->MappedCount);
766 ASSERT(Refs == 1);
767
768 /* Reset it, this is the one we want to free */
769 RemoveEntryList(&current->CacheMapVacbListEntry);
770 InitializeListHead(&current->CacheMapVacbListEntry);
771 RemoveEntryList(&current->VacbLruListEntry);
772 InitializeListHead(&current->VacbLruListEntry);
773
774 to_free = current;
775 }
776
777 KeReleaseSpinLockFromDpcLevel(&current->SharedCacheMap->CacheMapLock);
778
779 current_entry = current_entry->Flink;
780 }
781
783
784 /* And now, free the VACB that we found, if any. */
785 if (to_free == NULL)
786 {
787 return FALSE;
788 }
789
790 /* This must be its last ref */
791 NT_VERIFY(CcRosVacbDecRefCount(to_free) == 0);
792
793 return TRUE;
794}
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
#define CcRosVacbGetRefCount(vacb)
Definition: cc.h:511
#define NT_VERIFY(exp)
Definition: rtlfuncs.h:3304

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.

982{
985 ULONG Refs;
987
988 ASSERT(SharedCacheMap);
989
990 DPRINT("CcRosGetVacb()\n");
991
992 /*
993 * Look for a VACB already mapping the same data.
994 */
995 current = CcRosLookupVacb(SharedCacheMap, FileOffset);
996 if (current == NULL)
997 {
998 /*
999 * Otherwise create a new VACB.
1000 */
1001 Status = CcRosCreateVacb(SharedCacheMap, FileOffset, &current);
1002 if (!NT_SUCCESS(Status))
1003 {
1004 return Status;
1005 }
1006 }
1007
1009
1011
1012 /* Move to the tail of the LRU list */
1013 RemoveEntryList(&current->VacbLruListEntry);
1014 InsertTailList(&VacbLruListHead, &current->VacbLruListEntry);
1015
1017
1018 /*
1019 * Return the VACB to the caller.
1020 */
1021 *Vacb = current;
1022
1023 ASSERT(Refs > 1);
1024
1025 return STATUS_SUCCESS;
1026}
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:160
PROS_VACB CcRosLookupVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset)
Definition: view.c:624
static NTSTATUS CcRosCreateVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset, PROS_VACB *Vacb)
Definition: view.c:798

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.

1295{
1296 KIRQL OldIrql;
1298 PROS_SHARED_CACHE_MAP SharedCacheMap;
1299
1300 DPRINT("CcRosInitializeFileCache(FileObject 0x%p)\n", FileObject);
1301
1303
1304 Allocated = FALSE;
1305 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1306 if (SharedCacheMap == NULL)
1307 {
1308 SharedCacheMap = ExAllocateFromNPagedLookasideList(&SharedCacheMapLookasideList);
1309 if (SharedCacheMap == NULL)
1310 {
1313 }
1314 RtlZeroMemory(SharedCacheMap, sizeof(*SharedCacheMap));
1315 SharedCacheMap->NodeTypeCode = NODE_TYPE_SHARED_MAP;
1316 SharedCacheMap->NodeByteSize = sizeof(*SharedCacheMap);
1317 SharedCacheMap->FileObject = FileObject;
1318 SharedCacheMap->Callbacks = CallBacks;
1319 SharedCacheMap->LazyWriteContext = LazyWriterContext;
1320 SharedCacheMap->SectionSize = FileSizes->AllocationSize;
1321 SharedCacheMap->FileSize = FileSizes->FileSize;
1322 SharedCacheMap->ValidDataLength = FileSizes->ValidDataLength;
1323 SharedCacheMap->PinAccess = PinAccess;
1324 SharedCacheMap->DirtyPageThreshold = 0;
1325 SharedCacheMap->DirtyPages = 0;
1326 InitializeListHead(&SharedCacheMap->PrivateList);
1327 KeInitializeSpinLock(&SharedCacheMap->CacheMapLock);
1328 InitializeListHead(&SharedCacheMap->CacheMapVacbListHead);
1329 InitializeListHead(&SharedCacheMap->BcbList);
1330 KeInitializeGuardedMutex(&SharedCacheMap->FlushCacheLock);
1331
1332 SharedCacheMap->Flags = SHARED_CACHE_MAP_IN_CREATION;
1333
1336 NULL,
1337 KernelMode);
1338
1339 Allocated = TRUE;
1340 FileObject->SectionObjectPointer->SharedCacheMap = SharedCacheMap;
1341
1342 //CcRosTraceCacheMap(SharedCacheMap, TRUE);
1343 }
1344 else if (SharedCacheMap->Flags & SHARED_CACHE_MAP_IN_CREATION)
1345 {
1346 /* The shared cache map is being created somewhere else. Wait for that to happen */
1347 KEVENT Waiter;
1348 PKEVENT PreviousWaiter = SharedCacheMap->CreateEvent;
1349
1351 SharedCacheMap->CreateEvent = &Waiter;
1352
1354
1356
1357 if (PreviousWaiter)
1358 KeSetEvent(PreviousWaiter, IO_NO_INCREMENT, FALSE);
1359
1361 }
1362
1363 if (FileObject->PrivateCacheMap == NULL)
1364 {
1365 PPRIVATE_CACHE_MAP PrivateMap;
1366
1367 /* Allocate the private cache map for this handle */
1368 if (SharedCacheMap->PrivateCacheMap.NodeTypeCode != 0)
1369 {
1371 }
1372 else
1373 {
1374 PrivateMap = &SharedCacheMap->PrivateCacheMap;
1375 }
1376
1377 if (PrivateMap == NULL)
1378 {
1379 /* If we also allocated the shared cache map for this file, kill it */
1380 if (Allocated)
1381 {
1382 RemoveEntryList(&SharedCacheMap->SharedCacheMapLinks);
1383
1384 FileObject->SectionObjectPointer->SharedCacheMap = NULL;
1386 ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap);
1387 }
1388
1391 }
1392
1393 /* Initialize it */
1394 RtlZeroMemory(PrivateMap, sizeof(PRIVATE_CACHE_MAP));
1395 PrivateMap->NodeTypeCode = NODE_TYPE_PRIVATE_MAP;
1396 PrivateMap->ReadAheadMask = PAGE_SIZE - 1;
1397 PrivateMap->FileObject = FileObject;
1399
1400 /* Link it to the file */
1401 KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
1402 InsertTailList(&SharedCacheMap->PrivateList, &PrivateMap->PrivateLinks);
1404
1405 FileObject->PrivateCacheMap = PrivateMap;
1406 SharedCacheMap->OpenCount++;
1407 }
1408
1410
1411 /* Create the section */
1412 if (Allocated)
1413 {
1415
1416 ASSERT(SharedCacheMap->Section == NULL);
1417
1419 &SharedCacheMap->Section,
1421 NULL,
1422 &SharedCacheMap->SectionSize,
1425 NULL,
1426 FileObject);
1427
1429
1430 if (!NT_SUCCESS(Status))
1431 {
1433 return Status;
1434 }
1435
1437
1439 SharedCacheMap->Flags &= ~SHARED_CACHE_MAP_IN_CREATION;
1440
1441 if (SharedCacheMap->CreateEvent)
1442 {
1443 KeSetEvent(SharedCacheMap->CreateEvent, IO_NO_INCREMENT, FALSE);
1444 SharedCacheMap->CreateEvent = NULL;
1445 }
1446
1448 }
1449
1450 return STATUS_SUCCESS;
1451}
static CC_FILE_SIZES FileSizes
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
#define NonPagedPool
Definition: env_spec_w32.h:307
IN PFCB IN VBO OUT PLBO OUT PULONG OUT PBOOLEAN Allocated
Definition: fatprocs.h:311
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
#define KernelMode
Definition: asm.h:38
#define PAGE_READWRITE
Definition: nt_native.h:1304
#define SECTION_ALL_ACCESS
Definition: nt_native.h:1293
#define SEC_RESERVE
Definition: nt_native.h:1323
#define FILE_ALL_ACCESS
Definition: nt_native.h:651
@ NotificationEvent
NTSTATUS CcRosReleaseFileCache(PFILE_OBJECT FileObject)
Definition: view.c:1230
#define NODE_TYPE_PRIVATE_MAP
Definition: cc.h:288
#define SHARED_CACHE_MAP_IN_CREATION
Definition: cc.h:204
#define NODE_TYPE_SHARED_MAP
Definition: cc.h:289
NTSTATUS NTAPI ObReferenceObjectByPointer(IN PVOID Object, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode)
Definition: obref.c:381
NTSTATUS NTAPI MmCreateSection(OUT PVOID *Section, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN PLARGE_INTEGER MaximumSize, IN ULONG SectionPageProtection, IN ULONG AllocationAttributes, IN HANDLE FileHandle OPTIONAL, IN PFILE_OBJECT FileObject OPTIONAL)
Definition: section.c:4632
LARGE_INTEGER FileSize
Definition: cctypes.h:16
LARGE_INTEGER ValidDataLength
Definition: cctypes.h:17
LARGE_INTEGER AllocationSize
Definition: cctypes.h:15
PFILE_OBJECT FileObject
Definition: cctypes.h:76
ULONG ReadAheadMask
Definition: cctypes.h:75
CSHORT NodeTypeCode
Definition: cctypes.h:71
LIST_ENTRY PrivateLinks
Definition: cctypes.h:84
LIST_ENTRY CacheMapVacbListHead
Definition: cc.h:193
PRIVATE_CACHE_MAP PrivateCacheMap
Definition: cc.h:190
KSPIN_LOCK CacheMapLock
Definition: cc.h:195
PKEVENT CreateEvent
Definition: cc.h:184
LIST_ENTRY SharedCacheMapLinks
Definition: cc.h:181
CSHORT NodeTypeCode
Definition: cc.h:172
ULONG DirtyPageThreshold
Definition: cc.h:188
ULONG DirtyPages
Definition: cc.h:180
LIST_ENTRY PrivateList
Definition: cc.h:187
CSHORT NodeByteSize
Definition: cc.h:173
BOOLEAN PinAccess
Definition: cc.h:194
LIST_ENTRY BcbList
Definition: cc.h:176
KGUARDED_MUTEX FlushCacheLock
Definition: cc.h:196
#define TAG_PRIVATE_CACHE_MAP
Definition: tag.h:17
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
@ Executive
Definition: ketypes.h:415

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.

627{
628 PLIST_ENTRY current_entry;
630 KIRQL oldIrql;
631
632 ASSERT(SharedCacheMap);
633
634 DPRINT("CcRosLookupVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
635 SharedCacheMap, FileOffset);
636
639
640 current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
641 while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
642 {
643 current = CONTAINING_RECORD(current_entry,
644 ROS_VACB,
645 CacheMapVacbListEntry);
646 if (IsPointInRange(current->FileOffset.QuadPart,
648 FileOffset))
649 {
653 return current;
654 }
655 if (current->FileOffset.QuadPart > FileOffset)
656 break;
657 current_entry = current_entry->Flink;
658 }
659
662
663 return NULL;
664}
FORCEINLINE BOOLEAN IsPointInRange(_In_ LONGLONG Offset1, _In_ LONGLONG Length1, _In_ LONGLONG Point)
Definition: cc.h:462

Referenced by CcFlushCache(), and CcRosGetVacb().

◆ CcRosMarkDirtyVacb()

VOID CcRosMarkDirtyVacb ( PROS_VACB  Vacb)

Definition at line 667 of file view.c.

669{
670 KIRQL oldIrql;
671 PROS_SHARED_CACHE_MAP SharedCacheMap;
672
673 SharedCacheMap = Vacb->SharedCacheMap;
674
677
678 ASSERT(!Vacb->Dirty);
679
681 /* FIXME: There is no reason to account for the whole VACB. */
685
686 /* Move to the tail of the LRU list */
689
690 Vacb->Dirty = TRUE;
691
693
694 /* Schedule a lazy writer run to now that we have dirty VACB */
696 {
698 }
700}
VOID CcScheduleLazyWriteScan(IN BOOLEAN NoDelay)
Definition: lazywrite.c:210
LAZY_WRITER LazyWriter
Definition: lazywrite.c:37
ULONG CcTotalDirtyPages
Definition: view.c:57
BOOLEAN ScanActive
Definition: cc.h:247
BOOLEAN Dirty
Definition: cc.h:212
PROS_SHARED_CACHE_MAP SharedCacheMap
Definition: cc.h:227
LIST_ENTRY DirtyVacbListEntry
Definition: cc.h:219
LIST_ENTRY VacbLruListEntry
Definition: cc.h:221

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.

1236{
1237 KIRQL OldIrql;
1238 PPRIVATE_CACHE_MAP PrivateMap;
1239 PROS_SHARED_CACHE_MAP SharedCacheMap;
1240
1242
1243 if (FileObject->SectionObjectPointer->SharedCacheMap != NULL)
1244 {
1245 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1246
1247 /* Closing the handle, so kill the private cache map
1248 * Before you event try to remove it from FO, always
1249 * lock the master lock, to be sure not to race
1250 * with a potential read ahead ongoing!
1251 */
1252 PrivateMap = FileObject->PrivateCacheMap;
1253 FileObject->PrivateCacheMap = NULL;
1254
1255 if (PrivateMap != NULL)
1256 {
1257 /* Remove it from the file */
1258 KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
1259 RemoveEntryList(&PrivateMap->PrivateLinks);
1261
1262 /* And free it. */
1263 if (PrivateMap != &SharedCacheMap->PrivateCacheMap)
1264 {
1266 }
1267 else
1268 {
1269 PrivateMap->NodeTypeCode = 0;
1270 }
1271
1272 ASSERT(SharedCacheMap->OpenCount > 0);
1273
1274 SharedCacheMap->OpenCount--;
1275 if (SharedCacheMap->OpenCount == 0)
1276 {
1277 CcRosDeleteFileCache(FileObject, SharedCacheMap, &OldIrql);
1278 }
1279 }
1280 }
1282 return STATUS_SUCCESS;
1283}

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.

597{
598 ULONG Refs;
599 ASSERT(SharedCacheMap);
600
601 DPRINT("CcRosReleaseVacb(SharedCacheMap 0x%p, Vacb 0x%p)\n", SharedCacheMap, Vacb);
602
603 if (Dirty && !Vacb->Dirty)
604 {
605 CcRosMarkDirtyVacb(Vacb);
606 }
607
608 if (Mapped)
609 {
610 if (InterlockedIncrement((PLONG)&Vacb->MappedCount) == 1)
611 {
613 }
614 }
615
616 Refs = CcRosVacbDecRefCount(Vacb);
617 ASSERT(Refs > 0);
618
619 return STATUS_SUCCESS;
620}
#define InterlockedIncrement
Definition: armddk.h:53
ULONG MappedCount
Definition: cc.h:215
int32_t * PLONG
Definition: typedefs.h:58

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.

1036{
1037
1038 ASSERT(SharedCacheMap);
1039
1041 {
1042 DPRINT1("Bad FileOffset %I64x: should be multiple of %x\n",
1044 KeBugCheck(CACHE_MANAGER);
1045 }
1046
1047 return CcRosGetVacb(SharedCacheMap,
1048 FileOffset,
1049 Vacb);
1050}
NTSTATUS CcRosGetVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset, PROS_VACB *Vacb)
Definition: view.c:978

Referenced by CcPerformReadAhead().

◆ CcRosUnmarkDirtyVacb()

VOID CcRosUnmarkDirtyVacb ( PROS_VACB  Vacb,
BOOLEAN  LockViews 
)

Definition at line 703 of file view.c.

706{
707 KIRQL oldIrql;
708 PROS_SHARED_CACHE_MAP SharedCacheMap;
709
710 SharedCacheMap = Vacb->SharedCacheMap;
711
712 if (LockViews)
713 {
716 }
717
718 ASSERT(Vacb->Dirty);
719
720 Vacb->Dirty = FALSE;
721
724
727
729
730 if (LockViews)
731 {
734 }
735}

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

◆ CcRosVacbDecRefCount()

FORCEINLINE ULONG CcRosVacbDecRefCount ( PROS_VACB  vacb)

Definition at line 499 of file cc.h.

501{
502 ULONG Refs;
503
505 if (Refs == 0)
506 {
508 }
509 return Refs;
510}
#define InterlockedDecrement
Definition: armddk.h:52
NTSTATUS CcRosInternalFreeVacb(IN PROS_VACB Vacb)
volatile ULONG ReferenceCount
Definition: cc.h:225

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.

300{
301 ULONG i, Result;
303
304 DPRINT1("CC: Shutdown\n");
305
306 for (i = 0; i < CACHE_NUM_SECTIONS; i++)
307 {
309 if (Bcb->SectionObject)
310 {
311 DPRINT1("Evicting #%02x %08x%08x %wZ\n",
312 i,
313 Bcb->FileOffset.u.HighPart,
314 Bcb->FileOffset.u.LowPart,
315 &MmGetFileObjectForSection((PROS_SECTION_OBJECT)Bcb->SectionObject)->FileName);
316
317 CcpFlushCache(Bcb->Map, NULL, 0, NULL, TRUE);
318 Bcb->Dirty = FALSE;
319 }
320 }
321
322 /* Evict all section pages */
323 Status = MiRosTrimCache(~0, 0, &Result);
324
325 DPRINT1("Done (Evicted %d, Status %x)\n", Result, Status);
326}
IN PVCB IN VBO IN ULONG OUT PBCB * Bcb
Definition: fatprocs.h:415
#define CcpFlushCache(M, F, L, I, D)
Definition: newcc.h:91
NTSTATUS MiRosTrimCache(ULONG Target, ULONG Priority, PULONG NrFreed)
Definition: swapout.c:633
PFILE_OBJECT NTAPI MmGetFileObjectForSection(IN PVOID Section)
Definition: section.c:1540
Definition: newcc.h:4
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409

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.

452{
453 if (Offset1 + Length1 <= Offset2)
454 return FALSE;
455 if (Offset2 + Length2 <= Offset1)
456 return FALSE;
457 return TRUE;
458}
INT Offset2
Definition: FsRtlDissect.c:14
INT Offset1
Definition: FsRtlDissect.c:13
INT Length2
Definition: FsRtlDissect.c:16
INT Length1
Definition: FsRtlDissect.c:15

Referenced by IsPointInRange().

◆ IsPointInRange()

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

Definition at line 462 of file cc.h.

466{
468}
FORCEINLINE BOOLEAN DoRangesIntersect(_In_ LONGLONG Offset1, _In_ LONGLONG Length1, _In_ LONGLONG Offset2, _In_ LONGLONG Length2)
Definition: cc.h:447

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

◆ 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

◆ 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

◆ CcTwilightLookasideList

◆ DirtyVacbListHead

LIST_ENTRY DirtyVacbListHead
extern

Definition at line 42 of file view.c.

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

◆ LazyWriter