ntoskrnl/cc/cacheman.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS kernel
   4  * FILE:            ntoskrnl/cc/cacheman.c
   5  * PURPOSE:         Cache manager
   6  *
   7  * PROGRAMMERS:     David Welch (welch@cwcom.net)
   8  *                  Pierre Schweitzer (pierre@reactos.org)
   9  */
  10
  11 /* INCLUDES *****************************************************************/
  12
  13 #include <ntoskrnl.h>
  14 #define NDEBUG
  15 #include <debug.h>
  16
  17 BOOLEAN CcPfEnablePrefetcher;
  18 PFSN_PREFETCHER_GLOBALS CcPfGlobals;
  19 MM_SYSTEMSIZE CcCapturedSystemSize;
  20
  21 static ULONG BugCheckFileId = 0x4 << 16;
  22
  23 /* FUNCTIONS *****************************************************************/
  24
  25 VOID
  26 NTAPI
  27 INIT_FUNCTION
  28 CcPfInitializePrefetcher(VOID)
  29 {
  30     /* Notify debugger */
  31     DbgPrintEx(DPFLTR_PREFETCHER_ID,
  32                DPFLTR_TRACE_LEVEL,
  33                "CCPF: InitializePrefetecher()\n");
  34
  35     /* Setup the Prefetcher Data */
  36     InitializeListHead(&CcPfGlobals.ActiveTraces);
  37     InitializeListHead(&CcPfGlobals.CompletedTraces);
  38     ExInitializeFastMutex(&CcPfGlobals.CompletedTracesLock);
  39
  40     /* FIXME: Setup the rest of the prefetecher */
  41 }
  42
  43 BOOLEAN
  44 NTAPI
  45 INIT_FUNCTION
  46 CcInitializeCacheManager(VOID)
  47 {
  48     ULONG Thread;
  49
  50     CcInitView();
  51
  52     /* Initialize lazy-writer lists */
  53     InitializeListHead(&CcIdleWorkerThreadList);
  54     InitializeListHead(&CcRegularWorkQueue);
  55     InitializeListHead(&CcPostTickWorkQueue);
  56
  57     /* Define lazy writer threshold and the amount of workers,
  58       * depending on the system type
  59       */
  60     CcCapturedSystemSize = MmQuerySystemSize();
  61     switch (CcCapturedSystemSize)
  62     {
  63         case MmSmallSystem:
  64             CcNumberWorkerThreads = ExCriticalWorkerThreads - 1;
  65             CcDirtyPageThreshold = MmNumberOfPhysicalPages / 8;
  66             break;
  67
  68         case MmMediumSystem:
  69             CcNumberWorkerThreads = ExCriticalWorkerThreads - 1;
  70             CcDirtyPageThreshold = MmNumberOfPhysicalPages / 4;
  71             break;
  72
  73         case MmLargeSystem:
  74             CcNumberWorkerThreads = ExCriticalWorkerThreads - 2;
  75             CcDirtyPageThreshold = MmNumberOfPhysicalPages / 8 + MmNumberOfPhysicalPages / 4;
  76             break;
  77
  78         default:
  79             CcNumberWorkerThreads = 1;
  80             CcDirtyPageThreshold = MmNumberOfPhysicalPages / 8;
  81             break;
  82     }
  83
  84     /* Allocate a work item for all our threads */
  85     for (Thread = 0; Thread < CcNumberWorkerThreads; ++Thread)
  86     {
  87         PWORK_QUEUE_ITEM Item;
  88
  89         Item = ExAllocatePoolWithTag(NonPagedPool, sizeof(WORK_QUEUE_ITEM), 'qWcC');
  90         if (Item == NULL)
  91         {
  92             CcBugCheck(0, 0, 0);
  93         }
  94
  95         /* By default, it's obviously idle */
  96         ExInitializeWorkItem(Item, CcWorkerThread, Item);
  97         InsertTailList(&CcIdleWorkerThreadList, &Item->List);
  98     }
  99
 100     /* Initialize our lazy writer */
 101     RtlZeroMemory(&LazyWriter, sizeof(LazyWriter));
 102     InitializeListHead(&LazyWriter.WorkQueue);
 103     /* Delay activation of the lazy writer */
 104     KeInitializeDpc(&LazyWriter.ScanDpc, CcScanDpc, NULL);
 105     KeInitializeTimer(&LazyWriter.ScanTimer);
 106
 107     /* Lookaside list for our work items */
 108     ExInitializeNPagedLookasideList(&CcTwilightLookasideList, NULL, NULL, 0, sizeof(WORK_QUEUE_ENTRY), 'KWcC', 0);
 109
 110     return TRUE;
 111 }
 112
 113 VOID
 114 NTAPI
 115 CcShutdownSystem(VOID)
 116 {
 117     /* NOTHING TO DO */
 118 }
 119
 120 /*
 121  * @unimplemented
 122  */
 123 LARGE_INTEGER
 124 NTAPI
 125 CcGetFlushedValidData (
 126     IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
 127     IN BOOLEAN BcbListHeld
 128     )
 129 {
 130         LARGE_INTEGER i;
 131
 132         UNIMPLEMENTED;
 133
 134         i.QuadPart = 0;
 135         return i;
 136 }
 137
 138 /*
 139  * @unimplemented
 140  */
 141 PVOID
 142 NTAPI
 143 CcRemapBcb (
 144     IN PVOID Bcb
 145     )
 146 {
 147         UNIMPLEMENTED;
 148
 149     return 0;
 150 }
 151
 152 /*
 153  * @unimplemented
 154  */
 155 VOID
 156 NTAPI
 157 CcScheduleReadAhead (
 158         IN      PFILE_OBJECT            FileObject,
 159         IN      PLARGE_INTEGER          FileOffset,
 160         IN      ULONG                   Length
 161         )
 162 {
 163         UNIMPLEMENTED;
 164 }
 165
 166 /*
 167  * @implemented
 168  */
 169 VOID
 170 NTAPI
 171 CcSetAdditionalCacheAttributes (
 172         IN      PFILE_OBJECT    FileObject,
 173         IN      BOOLEAN         DisableReadAhead,
 174         IN      BOOLEAN         DisableWriteBehind
 175         )
 176 {
 177     KIRQL OldIrql;
 178     PROS_SHARED_CACHE_MAP SharedCacheMap;
 179
 180     CCTRACE(CC_API_DEBUG, "FileObject=%p DisableReadAhead=%d DisableWriteBehind=%d\n",
 181         FileObject, DisableReadAhead, DisableWriteBehind);
 182
 183     SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
 184
 185     OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
 186
 187     if (DisableReadAhead)
 188     {
 189         SetFlag(SharedCacheMap->Flags, READAHEAD_DISABLED);
 190     }
 191     else
 192     {
 193         ClearFlag(SharedCacheMap->Flags, READAHEAD_DISABLED);
 194     }
 195
 196     if (DisableWriteBehind)
 197     {
 198         /* FIXME: also set flag 0x200 */
 199         SetFlag(SharedCacheMap->Flags, WRITEBEHIND_DISABLED);
 200     }
 201     else
 202     {
 203         ClearFlag(SharedCacheMap->Flags, WRITEBEHIND_DISABLED);
 204     }
 205     KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
 206 }
 207
 208 /*
 209  * @unimplemented
 210  */
 211 VOID
 212 NTAPI
 213 CcSetBcbOwnerPointer (
 214         IN      PVOID   Bcb,
 215         IN      PVOID   Owner
 216         )
 217 {
 218     PINTERNAL_BCB iBcb = Bcb;
 219
 220     CCTRACE(CC_API_DEBUG, "Bcb=%p Owner=%p\n",
 221         Bcb, Owner);
 222
 223     if (!ExIsResourceAcquiredExclusiveLite(&iBcb->Lock) && !ExIsResourceAcquiredSharedLite(&iBcb->Lock))
 224     {
 225         DPRINT1("Current thread doesn't own resource!\n");
 226         return;
 227     }
 228
 229     ExSetResourceOwnerPointer(&iBcb->Lock, Owner);
 230 }
 231
 232 /*
 233  * @implemented
 234  */
 235 VOID
 236 NTAPI
 237 CcSetDirtyPageThreshold (
 238         IN      PFILE_OBJECT    FileObject,
 239         IN      ULONG           DirtyPageThreshold
 240         )
 241 {
 242     PFSRTL_COMMON_FCB_HEADER Fcb;
 243     PROS_SHARED_CACHE_MAP SharedCacheMap;
 244
 245     CCTRACE(CC_API_DEBUG, "FileObject=%p DirtyPageThreshold=%lu\n",
 246         FileObject, DirtyPageThreshold);
 247
 248     SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
 249     if (SharedCacheMap != NULL)
 250     {
 251         SharedCacheMap->DirtyPageThreshold = DirtyPageThreshold;
 252     }
 253
 254     Fcb = FileObject->FsContext;
 255     if (!BooleanFlagOn(Fcb->Flags, FSRTL_FLAG_LIMIT_MODIFIED_PAGES))
 256     {
 257         SetFlag(Fcb->Flags, FSRTL_FLAG_LIMIT_MODIFIED_PAGES);
 258     }
 259 }
 260
 261 /*
 262  * @implemented
 263  */
 264 VOID
 265 NTAPI
 266 CcSetReadAheadGranularity (
 267         IN      PFILE_OBJECT    FileObject,
 268         IN      ULONG           Granularity
 269         )
 270 {
 271     PPRIVATE_CACHE_MAP PrivateMap;
 272
 273     CCTRACE(CC_API_DEBUG, "FileObject=%p Granularity=%lu\n",
 274         FileObject, Granularity);
 275
 276     PrivateMap = FileObject->PrivateCacheMap;
 277     PrivateMap->ReadAheadMask = Granularity - 1;
 278 }