ntoskrnl/include/internal/cc.h

   1 #pragma once
   2
   3 //
   4 // Define this if you want debugging support
   5 //
   6 #define _CC_DEBUG_                                      0x00
   7
   8 //
   9 // These define the Debug Masks Supported
  10 //
  11 #define CC_API_DEBUG                                    0x01
  12
  13 //
  14 // Debug/Tracing support
  15 //
  16 #if _CC_DEBUG_
  17 #ifdef NEW_DEBUG_SYSTEM_IMPLEMENTED // enable when Debug Filters are implemented
  18 #define CCTRACE(x, ...)                                     \
  19     {                                                       \
  20         DbgPrintEx("%s [%.16s] - ",                         \
  21                    __FUNCTION__,                            \
  22                    PsGetCurrentProcess()->ImageFileName);   \
  23         DbgPrintEx(__VA_ARGS__);                            \
  24     }
  25 #else
  26 #define CCTRACE(x, ...)                                     \
  27     if (x & CcRosTraceLevel)                                \
  28     {                                                       \
  29         DbgPrint("%s [%.16s] - ",                           \
  30                  __FUNCTION__,                              \
  31                  PsGetCurrentProcess()->ImageFileName);     \
  32         DbgPrint(__VA_ARGS__);                              \
  33     }
  34 #endif
  35 #else
  36 #define CCTRACE(x, fmt, ...) DPRINT(fmt, ##__VA_ARGS__)
  37 #endif
  38
  39 //
  40 // Global Cc Data
  41 //
  42 extern ULONG CcRosTraceLevel;
  43 extern LIST_ENTRY DirtyVacbListHead;
  44 extern ULONG CcDirtyPageThreshold;
  45 extern ULONG CcTotalDirtyPages;
  46 extern LIST_ENTRY CcDeferredWrites;
  47 extern KSPIN_LOCK CcDeferredWriteSpinLock;
  48 extern ULONG CcNumberWorkerThreads;
  49 extern LIST_ENTRY CcIdleWorkerThreadList;
  50 extern LIST_ENTRY CcExpressWorkQueue;
  51 extern LIST_ENTRY CcRegularWorkQueue;
  52 extern LIST_ENTRY CcPostTickWorkQueue;
  53 extern NPAGED_LOOKASIDE_LIST CcTwilightLookasideList;
  54 extern LARGE_INTEGER CcIdleDelay;
  55
  56 //
  57 // Counters
  58 //
  59 extern ULONG CcLazyWritePages;
  60 extern ULONG CcLazyWriteIos;
  61 extern ULONG CcMapDataWait;
  62 extern ULONG CcMapDataNoWait;
  63 extern ULONG CcPinReadWait;
  64 extern ULONG CcPinReadNoWait;
  65
  66 typedef struct _PF_SCENARIO_ID
  67 {
  68     WCHAR ScenName[30];
  69     ULONG HashId;
  70 } PF_SCENARIO_ID, *PPF_SCENARIO_ID;
  71
  72 typedef struct _PF_LOG_ENTRY
  73 {
  74     ULONG FileOffset:30;
  75     ULONG Type:2;
  76     union
  77     {
  78         ULONG FileKey;
  79         ULONG FileSequenceNumber;
  80     };
  81 } PF_LOG_ENTRY, *PPF_LOG_ENTRY;
  82
  83 typedef struct _PFSN_LOG_ENTRIES
  84 {
  85     LIST_ENTRY TraceBuffersLink;
  86     LONG NumEntries;
  87     LONG MaxEntries;
  88     PF_LOG_ENTRY Entries[ANYSIZE_ARRAY];
  89 } PFSN_LOG_ENTRIES, *PPFSN_LOG_ENTRIES;
  90
  91 typedef struct _PF_SECTION_INFO
  92 {
  93     ULONG FileKey;
  94     ULONG FileSequenceNumber;
  95     ULONG FileIdLow;
  96     ULONG FileIdHigh;
  97 } PF_SECTION_INFO, *PPF_SECTION_INFO;
  98
  99 typedef struct _PF_TRACE_HEADER
 100 {
 101     ULONG Version;
 102     ULONG MagicNumber;
 103     ULONG Size;
 104     PF_SCENARIO_ID ScenarioId;
 105     ULONG ScenarioType; // PF_SCENARIO_TYPE
 106     ULONG EventEntryIdxs[8];
 107     ULONG NumEventEntryIdxs;
 108     ULONG TraceBufferOffset;
 109     ULONG NumEntries;
 110     ULONG SectionInfoOffset;
 111     ULONG NumSections;
 112     ULONG FaultsPerPeriod[10];
 113     LARGE_INTEGER LaunchTime;
 114     ULONGLONG Reserved[5];
 115 } PF_TRACE_HEADER, *PPF_TRACE_HEADER;
 116
 117 typedef struct _PFSN_TRACE_DUMP
 118 {
 119     LIST_ENTRY CompletedTracesLink;
 120     PF_TRACE_HEADER Trace;
 121 } PFSN_TRACE_DUMP, *PPFSN_TRACE_DUMP;
 122
 123 typedef struct _PFSN_TRACE_HEADER
 124 {
 125     ULONG Magic;
 126     LIST_ENTRY ActiveTracesLink;
 127     PF_SCENARIO_ID ScenarioId;
 128     ULONG ScenarioType; // PF_SCENARIO_TYPE
 129     ULONG EventEntryIdxs[8];
 130     ULONG NumEventEntryIdxs;
 131     PPFSN_LOG_ENTRIES CurrentTraceBuffer;
 132     LIST_ENTRY TraceBuffersList;
 133     ULONG NumTraceBuffers;
 134     KSPIN_LOCK TraceBufferSpinLock;
 135     KTIMER TraceTimer;
 136     LARGE_INTEGER TraceTimerPeriod;
 137     KDPC TraceTimerDpc;
 138     KSPIN_LOCK TraceTimerSpinLock;
 139     ULONG FaultsPerPeriod[10];
 140     LONG LastNumFaults;
 141     LONG CurPeriod;
 142     LONG NumFaults;
 143     LONG MaxFaults;
 144     PEPROCESS Process;
 145     EX_RUNDOWN_REF RefCount;
 146     WORK_QUEUE_ITEM EndTraceWorkItem;
 147     LONG EndTraceCalled;
 148     PPFSN_TRACE_DUMP TraceDump;
 149     NTSTATUS TraceDumpStatus;
 150     LARGE_INTEGER LaunchTime;
 151     PPF_SECTION_INFO SectionInfo;
 152     ULONG SectionInfoCount;
 153 } PFSN_TRACE_HEADER, *PPFSN_TRACE_HEADER;
 154
 155 typedef struct _PFSN_PREFETCHER_GLOBALS
 156 {
 157     LIST_ENTRY ActiveTraces;
 158     KSPIN_LOCK ActiveTracesLock;
 159     PPFSN_TRACE_HEADER SystemWideTrace;
 160     LIST_ENTRY CompletedTraces;
 161     FAST_MUTEX CompletedTracesLock;
 162     LONG NumCompletedTraces;
 163     PKEVENT CompletedTracesEvent;
 164     LONG ActivePrefetches;
 165 } PFSN_PREFETCHER_GLOBALS, *PPFSN_PREFETCHER_GLOBALS;
 166
 167 typedef struct _ROS_SHARED_CACHE_MAP
 168 {
 169     CSHORT NodeTypeCode;
 170     CSHORT NodeByteSize;
 171     ULONG OpenCount;
 172     LARGE_INTEGER FileSize;
 173     LARGE_INTEGER SectionSize;
 174     PFILE_OBJECT FileObject;
 175     ULONG DirtyPages;
 176     LIST_ENTRY SharedCacheMapLinks;
 177     ULONG Flags;
 178     PCACHE_MANAGER_CALLBACKS Callbacks;
 179     PVOID LazyWriteContext;
 180     LIST_ENTRY PrivateList;
 181     ULONG DirtyPageThreshold;
 182     PRIVATE_CACHE_MAP PrivateCacheMap;
 183
 184     /* ROS specific */
 185     LIST_ENTRY CacheMapVacbListHead;
 186     ULONG TimeStamp;
 187     BOOLEAN PinAccess;
 188     KSPIN_LOCK CacheMapLock;
 189 #if DBG
 190     BOOLEAN Trace; /* enable extra trace output for this cache map and it's VACBs */
 191 #endif
 192 } ROS_SHARED_CACHE_MAP, *PROS_SHARED_CACHE_MAP;
 193
 194 #define READAHEAD_DISABLED 0x1
 195 #define WRITEBEHIND_DISABLED 0x2
 196
 197 typedef struct _ROS_VACB
 198 {
 199     /* Base address of the region where the view's data is mapped. */
 200     PVOID BaseAddress;
 201     /* Memory area representing the region where the view's data is mapped. */
 202     struct _MEMORY_AREA* MemoryArea;
 203     /* Are the contents of the view valid. */
 204     BOOLEAN Valid;
 205     /* Are the contents of the view newer than those on disk. */
 206     BOOLEAN Dirty;
 207     /* Page out in progress */
 208     BOOLEAN PageOut;
 209     ULONG MappedCount;
 210     /* Entry in the list of VACBs for this shared cache map. */
 211     LIST_ENTRY CacheMapVacbListEntry;
 212     /* Entry in the list of VACBs which are dirty. */
 213     LIST_ENTRY DirtyVacbListEntry;
 214     /* Entry in the list of VACBs. */
 215     LIST_ENTRY VacbLruListEntry;
 216     /* Offset in the file which this view maps. */
 217     LARGE_INTEGER FileOffset;
 218     /* Mutex */
 219     KMUTEX Mutex;
 220     /* Number of references. */
 221     ULONG ReferenceCount;
 222     /* How many times was it pinned? */
 223     _Guarded_by_(Mutex)
 224     LONG PinCount;
 225     /* Pointer to the shared cache map for the file which this view maps data for. */
 226     PROS_SHARED_CACHE_MAP SharedCacheMap;
 227     /* Pointer to the next VACB in a chain. */
 228 } ROS_VACB, *PROS_VACB;
 229
 230 typedef struct _INTERNAL_BCB
 231 {
 232     /* Lock */
 233     ERESOURCE Lock;
 234     PUBLIC_BCB PFCB;
 235     PROS_VACB Vacb;
 236     BOOLEAN Dirty;
 237     BOOLEAN Pinned;
 238     CSHORT RefCount; /* (At offset 0x34 on WinNT4) */
 239 } INTERNAL_BCB, *PINTERNAL_BCB;
 240
 241 typedef struct _LAZY_WRITER
 242 {
 243     LIST_ENTRY WorkQueue;
 244     KDPC ScanDpc;
 245     KTIMER ScanTimer;
 246     BOOLEAN ScanActive;
 247     BOOLEAN OtherWork;
 248     BOOLEAN PendingTeardown;
 249 } LAZY_WRITER, *PLAZY_WRITER;
 250
 251 typedef struct _WORK_QUEUE_ENTRY
 252 {
 253     LIST_ENTRY WorkQueueLinks;
 254     union
 255     {
 256         struct
 257         {
 258             FILE_OBJECT *FileObject;
 259         } Read;
 260         struct
 261         {
 262             SHARED_CACHE_MAP *SharedCacheMap;
 263         } Write;
 264         struct
 265         {
 266             KEVENT *Event;
 267         } Event;
 268         struct
 269         {
 270             unsigned long Reason;
 271         } Notification;
 272     } Parameters;
 273     unsigned char Function;
 274 } WORK_QUEUE_ENTRY, *PWORK_QUEUE_ENTRY;
 275
 276 typedef enum _WORK_QUEUE_FUNCTIONS
 277 {
 278     ReadAhead = 1,
 279     WriteBehind = 2,
 280     LazyWrite = 3,
 281     SetDone = 4,
 282 } WORK_QUEUE_FUNCTIONS, *PWORK_QUEUE_FUNCTIONS;
 283
 284 extern LAZY_WRITER LazyWriter;
 285
 286 #define NODE_TYPE_DEFERRED_WRITE 0x02FC
 287 #define NODE_TYPE_PRIVATE_MAP    0x02FE
 288 #define NODE_TYPE_SHARED_MAP     0x02FF
 289
 290 VOID
 291 NTAPI
 292 CcPfInitializePrefetcher(
 293     VOID
 294 );
 295
 296 VOID
 297 NTAPI
 298 CcMdlReadComplete2(
 299     IN PFILE_OBJECT FileObject,
 300     IN PMDL MemoryDescriptorList
 301 );
 302
 303 VOID
 304 NTAPI
 305 CcMdlWriteComplete2(
 306     IN PFILE_OBJECT FileObject,
 307     IN PLARGE_INTEGER FileOffset,
 308     IN PMDL MdlChain
 309 );
 310
 311 NTSTATUS
 312 NTAPI
 313 CcRosFlushVacb(PROS_VACB Vacb);
 314
 315 NTSTATUS
 316 NTAPI
 317 CcRosGetVacb(
 318     PROS_SHARED_CACHE_MAP SharedCacheMap,
 319     LONGLONG FileOffset,
 320     PLONGLONG BaseOffset,
 321     PVOID *BaseAddress,
 322     PBOOLEAN UptoDate,
 323     PROS_VACB *Vacb
 324 );
 325
 326 VOID
 327 NTAPI
 328 CcInitView(VOID);
 329
 330 VOID
 331 NTAPI
 332 CcShutdownLazyWriter(VOID);
 333
 334 NTSTATUS
 335 NTAPI
 336 CcReadVirtualAddress(PROS_VACB Vacb);
 337
 338 NTSTATUS
 339 NTAPI
 340 CcWriteVirtualAddress(PROS_VACB Vacb);
 341
 342 BOOLEAN
 343 NTAPI
 344 CcInitializeCacheManager(VOID);
 345
 346 NTSTATUS
 347 NTAPI
 348 CcRosUnmapVacb(
 349     PROS_SHARED_CACHE_MAP SharedCacheMap,
 350     LONGLONG FileOffset,
 351     BOOLEAN NowDirty
 352 );
 353
 354 PROS_VACB
 355 NTAPI
 356 CcRosLookupVacb(
 357     PROS_SHARED_CACHE_MAP SharedCacheMap,
 358     LONGLONG FileOffset
 359 );
 360
 361 VOID
 362 NTAPI
 363 CcInitCacheZeroPage(VOID);
 364
 365 NTSTATUS
 366 NTAPI
 367 CcRosMarkDirtyFile(
 368     PROS_SHARED_CACHE_MAP SharedCacheMap,
 369     LONGLONG FileOffset
 370 );
 371
 372 VOID
 373 NTAPI
 374 CcRosMarkDirtyVacb(
 375     PROS_VACB Vacb);
 376
 377 VOID
 378 NTAPI
 379 CcRosUnmarkDirtyVacb(
 380     PROS_VACB Vacb,
 381     BOOLEAN LockViews);
 382
 383 NTSTATUS
 384 NTAPI
 385 CcRosFlushDirtyPages(
 386     ULONG Target,
 387     PULONG Count,
 388     BOOLEAN Wait,
 389     BOOLEAN CalledFromLazy
 390 );
 391
 392 VOID
 393 NTAPI
 394 CcRosDereferenceCache(PFILE_OBJECT FileObject);
 395
 396 VOID
 397 NTAPI
 398 CcRosReferenceCache(PFILE_OBJECT FileObject);
 399
 400 VOID
 401 NTAPI
 402 CcRosRemoveIfClosed(PSECTION_OBJECT_POINTERS SectionObjectPointer);
 403
 404 NTSTATUS
 405 NTAPI
 406 CcRosReleaseVacb(
 407     PROS_SHARED_CACHE_MAP SharedCacheMap,
 408     PROS_VACB Vacb,
 409     BOOLEAN Valid,
 410     BOOLEAN Dirty,
 411     BOOLEAN Mapped
 412 );
 413
 414 NTSTATUS
 415 NTAPI
 416 CcRosRequestVacb(
 417     PROS_SHARED_CACHE_MAP SharedCacheMap,
 418     LONGLONG FileOffset,
 419     PVOID* BaseAddress,
 420     PBOOLEAN UptoDate,
 421     PROS_VACB *Vacb
 422 );
 423
 424 NTSTATUS
 425 NTAPI
 426 CcRosInitializeFileCache(
 427     PFILE_OBJECT FileObject,
 428     PCC_FILE_SIZES FileSizes,
 429     BOOLEAN PinAccess,
 430     PCACHE_MANAGER_CALLBACKS CallBacks,
 431     PVOID LazyWriterContext
 432 );
 433
 434 NTSTATUS
 435 NTAPI
 436 CcRosReleaseFileCache(
 437     PFILE_OBJECT FileObject
 438 );
 439
 440 VOID
 441 NTAPI
 442 CcShutdownSystem(VOID);
 443
 444 VOID
 445 NTAPI
 446 CcWorkerThread(PVOID Parameter);
 447
 448 VOID
 449 NTAPI
 450 CcScanDpc(
 451     PKDPC Dpc,
 452     PVOID DeferredContext,
 453     PVOID SystemArgument1,
 454     PVOID SystemArgument2);
 455
 456 VOID
 457 CcScheduleLazyWriteScan(BOOLEAN NoDelay);
 458
 459 VOID
 460 CcPostDeferredWrites(VOID);
 461
 462 VOID
 463 CcPostWorkQueue(
 464     IN PWORK_QUEUE_ENTRY WorkItem,
 465     IN PLIST_ENTRY WorkQueue);
 466
 467 VOID
 468 CcPerformReadAhead(
 469     IN PFILE_OBJECT FileObject);
 470
 471 FORCEINLINE
 472 NTSTATUS
 473 CcRosAcquireVacbLock(
 474     _Inout_ PROS_VACB Vacb,
 475     _In_ PLARGE_INTEGER Timeout)
 476 {
 477     NTSTATUS Status;
 478     Status = KeWaitForSingleObject(&Vacb->Mutex,
 479                                    Executive,
 480                                    KernelMode,
 481                                    FALSE,
 482                                    Timeout);
 483     return Status;
 484 }
 485
 486 FORCEINLINE
 487 VOID
 488 CcRosReleaseVacbLock(
 489     _Inout_ PROS_VACB Vacb)
 490 {
 491     KeReleaseMutex(&Vacb->Mutex, FALSE);
 492 }
 493
 494 FORCEINLINE
 495 BOOLEAN
 496 DoRangesIntersect(
 497     _In_ LONGLONG Offset1,
 498     _In_ LONGLONG Length1,
 499     _In_ LONGLONG Offset2,
 500     _In_ LONGLONG Length2)
 501 {
 502     if (Offset1 + Length1 <= Offset2)
 503         return FALSE;
 504     if (Offset2 + Length2 <= Offset1)
 505         return FALSE;
 506     return TRUE;
 507 }
 508
 509 FORCEINLINE
 510 BOOLEAN
 511 IsPointInRange(
 512     _In_ LONGLONG Offset1,
 513     _In_ LONGLONG Length1,
 514     _In_ LONGLONG Point)
 515 {
 516     return DoRangesIntersect(Offset1, Length1, Point, 1);
 517 }
 518
 519 #define CcBugCheck(A, B, C) KeBugCheckEx(CACHE_MANAGER, BugCheckFileId | ((ULONG)(__LINE__)), A, B, C)