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