ReactOS 0.4.15-dev-6675-gcbc63d8
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 469 of file cc.h.

◆ CcRosVacbGetRefCount

#define CcRosVacbGetRefCount (   vacb)    InterlockedCompareExchange((PLONG)&(vacb)->ReferenceCount, 0, 0)

Definition at line 510 of file cc.h.

◆ CcRosVacbIncRefCount

#define CcRosVacbIncRefCount (   vacb)    InterlockedIncrement((PLONG)&(vacb)->ReferenceCount)

Definition at line 495 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 286 of file cc.h.

◆ NODE_TYPE_PRIVATE_MAP

#define NODE_TYPE_PRIVATE_MAP   0x02FE

Definition at line 287 of file cc.h.

◆ NODE_TYPE_SHARED_MAP

#define NODE_TYPE_SHARED_MAP   0x02FF

Definition at line 288 of file cc.h.

◆ READAHEAD_DISABLED

#define READAHEAD_DISABLED   0x1

Definition at line 201 of file cc.h.

◆ SHARED_CACHE_MAP_IN_CREATION

#define SHARED_CACHE_MAP_IN_CREATION   0x4

Definition at line 203 of file cc.h.

◆ SHARED_CACHE_MAP_IN_LAZYWRITE

#define SHARED_CACHE_MAP_IN_LAZYWRITE   0x8

Definition at line 204 of file cc.h.

◆ WRITEBEHIND_DISABLED

#define WRITEBEHIND_DISABLED   0x2

Definition at line 202 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 276 of file cc.h.

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

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:1431
#define TRUE
Definition: types.h:120
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
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:342
#define MC_SYSTEM
Definition: mm.h:115
#define MI_SET_USAGE(x)
Definition: mm.h:317
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:71
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 1446 of file view.c.

1448{
1449 DPRINT("CcInitView()\n");
1450
1457 NULL,
1458 NULL,
1459 0,
1460 sizeof(INTERNAL_BCB),
1461 TAG_BCB,
1462 20);
1464 NULL,
1465 NULL,
1466 0,
1467 sizeof(ROS_SHARED_CACHE_MAP),
1469 20);
1471 NULL,
1472 NULL,
1473 0,
1474 sizeof(ROS_VACB),
1475 TAG_VACB,
1476 20);
1477
1479}
#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:59
static LIST_ENTRY VacbLruListHead
Definition: view.c:42
KSPIN_LOCK CcDeferredWriteSpinLock
Definition: view.c:58
LIST_ENTRY CcDeferredWrites
Definition: view.c:57
NPAGED_LOOKASIDE_LIST iBcbLookasideList
Definition: view.c:44
LIST_ENTRY DirtyVacbListHead
Definition: view.c:41
static NPAGED_LOOKASIDE_LIST SharedCacheMapLookasideList
Definition: view.c:45
static NPAGED_LOOKASIDE_LIST VacbLookasideList
Definition: view.c:46
Definition: cc.h:207
#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: debug.h:115

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
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
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:85
#define InterlockedAnd
Definition: interlocked.h:62
#define ASSERT(a)
Definition: mode.c:44
static void Clear(void)
Definition: treeview.c:386
#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:571
NTSTATUS CcRosRequestVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset, PROS_VACB *Vacb)
Definition: view.c:1005
BOOLEAN CcRosEnsureVacbResident(_In_ PROS_VACB Vacb, _In_ BOOLEAN Wait, _In_ BOOLEAN NoRead, _In_ ULONG Offset, _In_ ULONG Length)
Definition: view.c:907
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#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:792
@ LockQueueMasterLock
Definition: ketypes.h:651
#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 DPFLTR_TRACE_LEVEL
Definition: kdtypes.h:32
NTSYSAPI ULONG __cdecl DbgPrintEx(_In_ ULONG ComponentId, _In_ ULONG Level, _In_z_ _Printf_format_string_ PCSTR Format,...)
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:654

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 907 of file view.c.

914{
916
918
919#if 0
920 if ((Vacb->FileOffset.QuadPart + Offset) > Vacb->SharedCacheMap->SectionSize.QuadPart)
921 {
922 DPRINT1("Vacb read beyond the file size!\n");
923 return FALSE;
924 }
925#endif
926
927 BaseAddress = (PVOID)((ULONG_PTR)Vacb->BaseAddress + Offset);
928
929 /* Check if the pages are resident */
931 {
932 if (!Wait)
933 {
934 return FALSE;
935 }
936
937 if (!NoRead)
938 {
939 PROS_SHARED_CACHE_MAP SharedCacheMap = Vacb->SharedCacheMap;
940 NTSTATUS Status = MmMakeDataSectionResident(SharedCacheMap->FileObject->SectionObjectPointer,
941 Vacb->FileOffset.QuadPart + Offset,
942 Length,
943 &SharedCacheMap->ValidDataLength);
944 if (!NT_SUCCESS(Status))
946 }
947 }
948
949 return TRUE;
950}
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
BOOLEAN NTAPI MmArePagesResident(_In_ PEPROCESS Process, _In_ PVOID BaseAddress, _In_ ULONG Length)
Definition: section.c:4763
NTSTATUS NTAPI MmMakeDataSectionResident(_In_ PSECTION_OBJECT_POINTERS SectionObjectPointer, _In_ LONGLONG Offset, _In_ ULONG Length, _In_ PLARGE_INTEGER ValidDataLength)
Definition: section.c:4908
#define ExRaiseStatus
Definition: ntoskrnl.h:114
LARGE_INTEGER ValidDataLength
Definition: cc.h:178
PFILE_OBJECT FileObject
Definition: cc.h:179
void * PVOID
Definition: typedefs.h:50
uint32_t ULONG_PTR
Definition: typedefs.h:65
_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 305 of file view.c.

310{
311 PLIST_ENTRY current_entry;
314 BOOLEAN FlushAll = (Target == MAXULONG);
315
316 DPRINT("CcRosFlushDirtyPages(Target %lu)\n", Target);
317
318 (*Count) = 0;
319
322
323 current_entry = DirtyVacbListHead.Flink;
324 if (current_entry == &DirtyVacbListHead)
325 {
326 DPRINT("No Dirty pages\n");
327 }
328
329 while (((current_entry != &DirtyVacbListHead) && (Target > 0)) || FlushAll)
330 {
331 PROS_SHARED_CACHE_MAP SharedCacheMap;
334
335 if (current_entry == &DirtyVacbListHead)
336 {
337 ASSERT(FlushAll);
339 break;
340 current_entry = DirtyVacbListHead.Flink;
341 }
342
343 current = CONTAINING_RECORD(current_entry,
344 ROS_VACB,
345 DirtyVacbListEntry);
346 current_entry = current_entry->Flink;
347
349
350 SharedCacheMap = current->SharedCacheMap;
351
352 /* When performing lazy write, don't handle temporary files */
353 if (CalledFromLazy && BooleanFlagOn(SharedCacheMap->FileObject->Flags, FO_TEMPORARY_FILE))
354 {
356 continue;
357 }
358
359 /* Don't attempt to lazy write the files that asked not to */
360 if (CalledFromLazy && BooleanFlagOn(SharedCacheMap->Flags, WRITEBEHIND_DISABLED))
361 {
363 continue;
364 }
365
366 ASSERT(current->Dirty);
367
368 /* Do not lazy-write the same file concurrently. Fastfat ASSERTS on that */
369 if (SharedCacheMap->Flags & SHARED_CACHE_MAP_IN_LAZYWRITE)
370 {
372 continue;
373 }
374
375 SharedCacheMap->Flags |= SHARED_CACHE_MAP_IN_LAZYWRITE;
376
377 /* Keep a ref on the shared cache map */
378 SharedCacheMap->OpenCount++;
379
381
382 Locked = SharedCacheMap->Callbacks->AcquireForLazyWrite(SharedCacheMap->LazyWriteContext, Wait);
383 if (!Locked)
384 {
385 DPRINT("Not locked!");
386 ASSERT(!Wait);
389 SharedCacheMap->Flags &= ~SHARED_CACHE_MAP_IN_LAZYWRITE;
390
391 if (--SharedCacheMap->OpenCount == 0)
392 CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap, &OldIrql);
393
394 continue;
395 }
396
399
400 SharedCacheMap->Callbacks->ReleaseFromLazyWrite(SharedCacheMap->LazyWriteContext);
401
402 /* We release the VACB before acquiring the lock again, because
403 * CcRosVacbDecRefCount might free the VACB, as CcRosFlushVacb dropped a
404 * Refcount. Freeing must be done outside of the lock.
405 * The refcount is decremented atomically. So this is OK. */
408
409 SharedCacheMap->Flags &= ~SHARED_CACHE_MAP_IN_LAZYWRITE;
410
411 if (--SharedCacheMap->OpenCount == 0)
412 CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap, &OldIrql);
413
416 {
417 DPRINT1("CC: Failed to flush VACB.\n");
418 }
419 else
420 {
421 ULONG PagesFreed;
422
423 /* How many pages did we free? */
424 PagesFreed = Iosb.Information / PAGE_SIZE;
425 (*Count) += PagesFreed;
426
427 if (!Wait)
428 {
429 /* Make sure we don't overflow target! */
430 if (Target < PagesFreed)
431 {
432 /* If we would have, jump to zero directly */
433 Target = 0;
434 }
435 else
436 {
437 Target -= PagesFreed;
438 }
439 }
440 }
441
442 current_entry = DirtyVacbListHead.Flink;
443 }
444
447
448 DPRINT("CcRosFlushDirtyPages() finished\n");
449 return STATUS_SUCCESS;
450}
return Iosb
Definition: create.c:4402
#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:205
NTSTATUS CcRosFlushVacb(_In_ PROS_VACB Vacb, _Out_opt_ PIO_STATUS_BLOCK Iosb)
Definition: view.c:159
#define CcRosVacbIncRefCount(vacb)
Definition: cc.h:495
#define WRITEBEHIND_DISABLED
Definition: cc.h:202
#define SHARED_CACHE_MAP_IN_LAZYWRITE
Definition: cc.h:204
FORCEINLINE ULONG CcRosVacbDecRefCount(PROS_VACB vacb)
Definition: cc.h:498
#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 159 of file view.c.

162{
164 BOOLEAN HaveLock = FALSE;
165 PROS_SHARED_CACHE_MAP SharedCacheMap = Vacb->SharedCacheMap;
166
168
169 /* Lock for flush, if we are not already the top-level */
171 {
172 Status = FsRtlAcquireFileForCcFlushEx(Vacb->SharedCacheMap->FileObject);
173 if (!NT_SUCCESS(Status))
174 goto quit;
175 HaveLock = TRUE;
176 }
177
178 Status = MmFlushSegment(SharedCacheMap->FileObject->SectionObjectPointer,
179 &Vacb->FileOffset,
181 Iosb);
182
183 if (HaveLock)
184 {
185 FsRtlReleaseFileForCcFlush(Vacb->SharedCacheMap->FileObject);
186 }
187
188quit:
189 if (!NT_SUCCESS(Status))
190 CcRosMarkDirtyVacb(Vacb);
191 else
192 {
193 /* Update VDL */
194 if (SharedCacheMap->ValidDataLength.QuadPart < (Vacb->FileOffset.QuadPart + VACB_MAPPING_GRANULARITY))
195 {
196 SharedCacheMap->ValidDataLength.QuadPart = Vacb->FileOffset.QuadPart + VACB_MAPPING_GRANULARITY;
197 }
198 }
199
200 return Status;
201}
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:646
VOID CcRosUnmarkDirtyVacb(PROS_VACB Vacb, BOOLEAN LockViews)
Definition: view.c:682
NTSTATUS NTAPI FsRtlAcquireFileForCcFlushEx(IN PFILE_OBJECT FileObject)
Definition: fastio.c:1692
VOID NTAPI FsRtlReleaseFileForCcFlush(IN PFILE_OBJECT FileObject)
Definition: fastio.c:1765
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:4928
PIRP NTAPI IoGetTopLevelIrp(VOID)
Definition: irp.c:1843

Referenced by CcFlushCache(), and CcRosFlushDirtyPages().

◆ CcRosFreeOneUnusedVacb()

BOOLEAN CcRosFreeOneUnusedVacb ( VOID  )

Definition at line 717 of file view.c.

719{
720 KIRQL oldIrql;
721 PLIST_ENTRY current_entry;
722 PROS_VACB to_free = NULL;
723
725
726 /* Browse all the available VACB */
727 current_entry = VacbLruListHead.Flink;
728 while ((current_entry != &VacbLruListHead) && (to_free == NULL))
729 {
730 ULONG Refs;
732
733 current = CONTAINING_RECORD(current_entry,
734 ROS_VACB,
735 VacbLruListEntry);
736
737 KeAcquireSpinLockAtDpcLevel(&current->SharedCacheMap->CacheMapLock);
738
739 /* Only deal with unused VACB, we will free them */
741 if (Refs < 2)
742 {
743 ASSERT(!current->Dirty);
744 ASSERT(!current->MappedCount);
745 ASSERT(Refs == 1);
746
747 /* Reset it, this is the one we want to free */
748 RemoveEntryList(&current->CacheMapVacbListEntry);
749 InitializeListHead(&current->CacheMapVacbListEntry);
750 RemoveEntryList(&current->VacbLruListEntry);
751 InitializeListHead(&current->VacbLruListEntry);
752
753 to_free = current;
754 }
755
756 KeReleaseSpinLockFromDpcLevel(&current->SharedCacheMap->CacheMapLock);
757
758 current_entry = current_entry->Flink;
759 }
760
762
763 /* And now, free the VACB that we found, if any. */
764 if (to_free == NULL)
765 {
766 return FALSE;
767 }
768
769 /* This must be its last ref */
770 NT_VERIFY(CcRosVacbDecRefCount(to_free) == 0);
771
772 return TRUE;
773}
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
#define CcRosVacbGetRefCount(vacb)
Definition: cc.h:510
#define NT_VERIFY(exp)
Definition: rtlfuncs.h:3287

Referenced by CcRosCreateVacb(), and CcWriteBehind().

◆ CcRosGetVacb()

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

Definition at line 954 of file view.c.

958{
961 ULONG Refs;
963
964 ASSERT(SharedCacheMap);
965
966 DPRINT("CcRosGetVacb()\n");
967
968 /*
969 * Look for a VACB already mapping the same data.
970 */
971 current = CcRosLookupVacb(SharedCacheMap, FileOffset);
972 if (current == NULL)
973 {
974 /*
975 * Otherwise create a new VACB.
976 */
977 Status = CcRosCreateVacb(SharedCacheMap, FileOffset, &current);
978 if (!NT_SUCCESS(Status))
979 {
980 return Status;
981 }
982 }
983
985
987
988 /* Move to the tail of the LRU list */
989 RemoveEntryList(&current->VacbLruListEntry);
990 InsertTailList(&VacbLruListHead, &current->VacbLruListEntry);
991
993
994 /*
995 * Return the VACB to the caller.
996 */
997 *Vacb = current;
998
999 ASSERT(Refs > 1);
1000
1001 return STATUS_SUCCESS;
1002}
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:160
PROS_VACB CcRosLookupVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset)
Definition: view.c:603
static NTSTATUS CcRosCreateVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset, PROS_VACB *Vacb)
Definition: view.c:777

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 1257 of file view.c.

1266{
1267 KIRQL OldIrql;
1269 PROS_SHARED_CACHE_MAP SharedCacheMap;
1270
1271 DPRINT("CcRosInitializeFileCache(FileObject 0x%p)\n", FileObject);
1272
1274
1275 Allocated = FALSE;
1276 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1277 if (SharedCacheMap == NULL)
1278 {
1279 Allocated = TRUE;
1280 SharedCacheMap = ExAllocateFromNPagedLookasideList(&SharedCacheMapLookasideList);
1281 if (SharedCacheMap == NULL)
1282 {
1284 }
1285 RtlZeroMemory(SharedCacheMap, sizeof(*SharedCacheMap));
1286 SharedCacheMap->NodeTypeCode = NODE_TYPE_SHARED_MAP;
1287 SharedCacheMap->NodeByteSize = sizeof(*SharedCacheMap);
1288 SharedCacheMap->FileObject = FileObject;
1289 SharedCacheMap->Callbacks = CallBacks;
1290 SharedCacheMap->LazyWriteContext = LazyWriterContext;
1291 SharedCacheMap->SectionSize = FileSizes->AllocationSize;
1292 SharedCacheMap->FileSize = FileSizes->FileSize;
1293 SharedCacheMap->ValidDataLength = FileSizes->ValidDataLength;
1294 SharedCacheMap->PinAccess = PinAccess;
1295 SharedCacheMap->DirtyPageThreshold = 0;
1296 SharedCacheMap->DirtyPages = 0;
1297 InitializeListHead(&SharedCacheMap->PrivateList);
1298 KeInitializeSpinLock(&SharedCacheMap->CacheMapLock);
1299 InitializeListHead(&SharedCacheMap->CacheMapVacbListHead);
1300 InitializeListHead(&SharedCacheMap->BcbList);
1301
1302 SharedCacheMap->Flags = SHARED_CACHE_MAP_IN_CREATION;
1303
1306 NULL,
1307 KernelMode);
1308
1309 FileObject->SectionObjectPointer->SharedCacheMap = SharedCacheMap;
1310
1311 //CcRosTraceCacheMap(SharedCacheMap, TRUE);
1312 }
1313 else if (SharedCacheMap->Flags & SHARED_CACHE_MAP_IN_CREATION)
1314 {
1315 /* The shared cache map is being created somewhere else. Wait for that to happen */
1316 KEVENT Waiter;
1317 PKEVENT PreviousWaiter = SharedCacheMap->CreateEvent;
1318
1320 SharedCacheMap->CreateEvent = &Waiter;
1321
1323
1325
1326 if (PreviousWaiter)
1327 KeSetEvent(PreviousWaiter, IO_NO_INCREMENT, FALSE);
1328
1330 }
1331
1332 if (FileObject->PrivateCacheMap == NULL)
1333 {
1334 PPRIVATE_CACHE_MAP PrivateMap;
1335
1336 /* Allocate the private cache map for this handle */
1337 if (SharedCacheMap->PrivateCacheMap.NodeTypeCode != 0)
1338 {
1340 }
1341 else
1342 {
1343 PrivateMap = &SharedCacheMap->PrivateCacheMap;
1344 }
1345
1346 if (PrivateMap == NULL)
1347 {
1348 /* If we also allocated the shared cache map for this file, kill it */
1349 if (Allocated)
1350 {
1351 RemoveEntryList(&SharedCacheMap->SharedCacheMapLinks);
1352
1353 FileObject->SectionObjectPointer->SharedCacheMap = NULL;
1355 ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap);
1356 }
1357
1360 }
1361
1362 /* Initialize it */
1363 RtlZeroMemory(PrivateMap, sizeof(PRIVATE_CACHE_MAP));
1364 PrivateMap->NodeTypeCode = NODE_TYPE_PRIVATE_MAP;
1365 PrivateMap->ReadAheadMask = PAGE_SIZE - 1;
1366 PrivateMap->FileObject = FileObject;
1368
1369 /* Link it to the file */
1370 KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
1371 InsertTailList(&SharedCacheMap->PrivateList, &PrivateMap->PrivateLinks);
1373
1374 FileObject->PrivateCacheMap = PrivateMap;
1375 SharedCacheMap->OpenCount++;
1376 }
1377
1379
1380 /* Create the section */
1381 if (Allocated)
1382 {
1384
1385 ASSERT(SharedCacheMap->Section == NULL);
1386
1388 &SharedCacheMap->Section,
1390 NULL,
1391 &SharedCacheMap->SectionSize,
1394 NULL,
1395 FileObject);
1396
1398
1399 if (!NT_SUCCESS(Status))
1400 {
1402 return Status;
1403 }
1404
1406
1408 SharedCacheMap->Flags &= ~SHARED_CACHE_MAP_IN_CREATION;
1409
1410 if (SharedCacheMap->CreateEvent)
1411 {
1412 KeSetEvent(SharedCacheMap->CreateEvent, IO_NO_INCREMENT, FALSE);
1413 SharedCacheMap->CreateEvent = NULL;
1414 }
1415
1417 }
1418
1419 return STATUS_SUCCESS;
1420}
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:310
#define KernelMode
Definition: asm.h:34
#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:1201
#define NODE_TYPE_PRIVATE_MAP
Definition: cc.h:287
#define SHARED_CACHE_MAP_IN_CREATION
Definition: cc.h:203
#define NODE_TYPE_SHARED_MAP
Definition: cc.h:288
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:4608
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
LARGE_INTEGER SectionSize
Definition: cc.h:177
CSHORT NodeByteSize
Definition: cc.h:173
BOOLEAN PinAccess
Definition: cc.h:194
LIST_ENTRY BcbList
Definition: cc.h:176
#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:403

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 603 of file view.c.

606{
607 PLIST_ENTRY current_entry;
609 KIRQL oldIrql;
610
611 ASSERT(SharedCacheMap);
612
613 DPRINT("CcRosLookupVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
614 SharedCacheMap, FileOffset);
615
618
619 current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
620 while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
621 {
622 current = CONTAINING_RECORD(current_entry,
623 ROS_VACB,
624 CacheMapVacbListEntry);
625 if (IsPointInRange(current->FileOffset.QuadPart,
627 FileOffset))
628 {
632 return current;
633 }
634 if (current->FileOffset.QuadPart > FileOffset)
635 break;
636 current_entry = current_entry->Flink;
637 }
638
641
642 return NULL;
643}
FORCEINLINE BOOLEAN IsPointInRange(_In_ LONGLONG Offset1, _In_ LONGLONG Length1, _In_ LONGLONG Point)
Definition: cc.h:461

Referenced by CcFlushCache(), and CcRosGetVacb().

◆ CcRosMarkDirtyVacb()

VOID CcRosMarkDirtyVacb ( PROS_VACB  Vacb)

Definition at line 646 of file view.c.

648{
649 KIRQL oldIrql;
650 PROS_SHARED_CACHE_MAP SharedCacheMap;
651
652 SharedCacheMap = Vacb->SharedCacheMap;
653
656
657 ASSERT(!Vacb->Dirty);
658
660 /* FIXME: There is no reason to account for the whole VACB. */
664
665 /* Move to the tail of the LRU list */
668
669 Vacb->Dirty = TRUE;
670
672
673 /* Schedule a lazy writer run to now that we have dirty VACB */
675 {
677 }
679}
VOID CcScheduleLazyWriteScan(IN BOOLEAN NoDelay)
Definition: lazywrite.c:210
LAZY_WRITER LazyWriter
Definition: lazywrite.c:37
ULONG CcTotalDirtyPages
Definition: view.c:56
BOOLEAN ScanActive
Definition: cc.h:246
BOOLEAN Dirty
Definition: cc.h:211
PROS_SHARED_CACHE_MAP SharedCacheMap
Definition: cc.h:226
LIST_ENTRY DirtyVacbListEntry
Definition: cc.h:218
LIST_ENTRY VacbLruListEntry
Definition: cc.h:220

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

◆ CcRosReferenceCache()

VOID CcRosReferenceCache ( PFILE_OBJECT  FileObject)

◆ CcRosReleaseFileCache()

NTSTATUS CcRosReleaseFileCache ( PFILE_OBJECT  FileObject)

Definition at line 1201 of file view.c.

1207{
1208 KIRQL OldIrql;
1209 PPRIVATE_CACHE_MAP PrivateMap;
1210 PROS_SHARED_CACHE_MAP SharedCacheMap;
1211
1213
1214 if (FileObject->SectionObjectPointer->SharedCacheMap != NULL)
1215 {
1216 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1217
1218 /* Closing the handle, so kill the private cache map
1219 * Before you event try to remove it from FO, always
1220 * lock the master lock, to be sure not to race
1221 * with a potential read ahead ongoing!
1222 */
1223 PrivateMap = FileObject->PrivateCacheMap;
1224 FileObject->PrivateCacheMap = NULL;
1225
1226 if (PrivateMap != NULL)
1227 {
1228 /* Remove it from the file */
1229 KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
1230 RemoveEntryList(&PrivateMap->PrivateLinks);
1232
1233 /* And free it. */
1234 if (PrivateMap != &SharedCacheMap->PrivateCacheMap)
1235 {
1237 }
1238 else
1239 {
1240 PrivateMap->NodeTypeCode = 0;
1241 }
1242
1243 ASSERT(SharedCacheMap->OpenCount > 0);
1244
1245 SharedCacheMap->OpenCount--;
1246 if (SharedCacheMap->OpenCount == 0)
1247 {
1248 CcRosDeleteFileCache(FileObject, SharedCacheMap, &OldIrql);
1249 }
1250 }
1251 }
1253 return STATUS_SUCCESS;
1254}

Referenced by CcRosInitializeFileCache(), and CcUninitializeCacheMap().

◆ CcRosReleaseVacb()

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

Definition at line 571 of file view.c.

576{
577 ULONG Refs;
578 ASSERT(SharedCacheMap);
579
580 DPRINT("CcRosReleaseVacb(SharedCacheMap 0x%p, Vacb 0x%p)\n", SharedCacheMap, Vacb);
581
582 if (Dirty && !Vacb->Dirty)
583 {
584 CcRosMarkDirtyVacb(Vacb);
585 }
586
587 if (Mapped)
588 {
589 if (InterlockedIncrement((PLONG)&Vacb->MappedCount) == 1)
590 {
592 }
593 }
594
595 Refs = CcRosVacbDecRefCount(Vacb);
596 ASSERT(Refs > 0);
597
598 return STATUS_SUCCESS;
599}
#define InterlockedIncrement
Definition: armddk.h:53
ULONG MappedCount
Definition: cc.h:214
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 1005 of file view.c.

1012{
1013
1014 ASSERT(SharedCacheMap);
1015
1017 {
1018 DPRINT1("Bad fileoffset %I64x should be multiple of %x",
1020 KeBugCheck(CACHE_MANAGER);
1021 }
1022
1023 return CcRosGetVacb(SharedCacheMap,
1024 FileOffset,
1025 Vacb);
1026}
NTSTATUS CcRosGetVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset, PROS_VACB *Vacb)
Definition: view.c:954

Referenced by CcPerformReadAhead().

◆ CcRosUnmarkDirtyVacb()

VOID CcRosUnmarkDirtyVacb ( PROS_VACB  Vacb,
BOOLEAN  LockViews 
)

Definition at line 682 of file view.c.

685{
686 KIRQL oldIrql;
687 PROS_SHARED_CACHE_MAP SharedCacheMap;
688
689 SharedCacheMap = Vacb->SharedCacheMap;
690
691 if (LockViews)
692 {
695 }
696
697 ASSERT(Vacb->Dirty);
698
699 Vacb->Dirty = FALSE;
700
703
706
708
709 if (LockViews)
710 {
713 }
714}

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

◆ CcRosVacbDecRefCount()

FORCEINLINE ULONG CcRosVacbDecRefCount ( PROS_VACB  vacb)

Definition at line 498 of file cc.h.

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

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:414
#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:1737
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 446 of file cc.h.

451{
452 if (Offset1 + Length1 <= Offset2)
453 return FALSE;
454 if (Offset2 + Length2 <= Offset1)
455 return FALSE;
456 return TRUE;
457}
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 461 of file cc.h.

465{
467}
FORCEINLINE BOOLEAN DoRangesIntersect(_In_ LONGLONG Offset1, _In_ LONGLONG Length1, _In_ LONGLONG Offset2, _In_ LONGLONG Length2)
Definition: cc.h:446

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 58 of file view.c.

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

◆ CcDirtyPageThreshold

ULONG CcDirtyPageThreshold
extern

Definition at line 55 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 41 of file view.c.

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

◆ LazyWriter