ntoskrnl/cache/cachesub.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel
   4  * FILE:            ntoskrnl/cache/cachesub.c
   5  * PURPOSE:         Logging and configuration routines
   6  * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
   7  *                  Art Yerkes
   8  */
   9
  10 /* INCLUDES *******************************************************************/
  11
  12 #include <ntoskrnl.h>
  13 #include "newcc.h"
  14 #include "section/newmm.h"
  15 #define NDEBUG
  16 #include <debug.h>
  17
  18 /* STRUCTURES *****************************************************************/
  19
  20 typedef struct _WORK_QUEUE_WITH_READ_AHEAD
  21 {
  22     WORK_QUEUE_ITEM WorkItem;
  23     PFILE_OBJECT FileObject;
  24     LARGE_INTEGER FileOffset;
  25     ULONG Length;
  26 } WORK_QUEUE_WITH_READ_AHEAD, *PWORK_QUEUE_WITH_READ_AHEAD;
  27
  28 /* FUNCTIONS ******************************************************************/
  29
  30 PDEVICE_OBJECT
  31 NTAPI
  32 MmGetDeviceObjectForFile(IN PFILE_OBJECT FileObject);
  33
  34 VOID
  35 NTAPI
  36 CcSetReadAheadGranularity(IN PFILE_OBJECT FileObject,
  37                           IN ULONG Granularity)
  38 {
  39     PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
  40     if (Map)
  41     {
  42         Map->ReadAheadGranularity = Granularity;
  43     }
  44 }
  45
  46 VOID
  47 NTAPI
  48 CcpReadAhead(PVOID Context)
  49 {
  50     LARGE_INTEGER Offset;
  51     PWORK_QUEUE_WITH_READ_AHEAD WorkItem = (PWORK_QUEUE_WITH_READ_AHEAD)Context;
  52     PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)WorkItem->FileObject->SectionObjectPointer->SharedCacheMap;
  53
  54     DPRINT1("Reading ahead %08x%08x:%x %wZ\n",
  55             WorkItem->FileOffset.HighPart,
  56             WorkItem->FileOffset.LowPart,
  57             WorkItem->Length,
  58             &WorkItem->FileObject->FileName);
  59
  60     Offset.HighPart = WorkItem->FileOffset.HighPart;
  61     Offset.LowPart = PAGE_ROUND_DOWN(WorkItem->FileOffset.LowPart);
  62     if (Map)
  63     {
  64         PLIST_ENTRY ListEntry;
  65         volatile char *chptr;
  66         PNOCC_BCB Bcb;
  67         for (ListEntry = Map->AssociatedBcb.Flink;
  68              ListEntry != &Map->AssociatedBcb;
  69              ListEntry = ListEntry->Flink)
  70         {
  71             Bcb = CONTAINING_RECORD(ListEntry, NOCC_BCB, ThisFileList);
  72             if ((Offset.QuadPart + WorkItem->Length < Bcb->FileOffset.QuadPart) ||
  73                 (Bcb->FileOffset.QuadPart + Bcb->Length < Offset.QuadPart))
  74                 continue;
  75             for (chptr = Bcb->BaseAddress, Offset = Bcb->FileOffset;
  76                  chptr < ((PCHAR)Bcb->BaseAddress) + Bcb->Length &&
  77                      Offset.QuadPart <
  78                      WorkItem->FileOffset.QuadPart + WorkItem->Length;
  79                  chptr += PAGE_SIZE, Offset.QuadPart += PAGE_SIZE)
  80             {
  81                 *chptr ^= 0;
  82             }
  83         }
  84     }
  85     ObDereferenceObject(WorkItem->FileObject);
  86     ExFreePool(WorkItem);
  87     DPRINT("Done\n");
  88 }
  89
  90 VOID
  91 NTAPI
  92 CcScheduleReadAhead(IN PFILE_OBJECT FileObject,
  93                     IN PLARGE_INTEGER FileOffset,
  94                     IN ULONG Length)
  95 {
  96     PWORK_QUEUE_WITH_READ_AHEAD WorkItem;
  97
  98     DPRINT("Schedule read ahead %08x%08x:%x %wZ\n",
  99            FileOffset->HighPart,
 100            FileOffset->LowPart,
 101            Length,
 102            &FileObject->FileName);
 103
 104     WorkItem = ExAllocatePool(NonPagedPool, sizeof(*WorkItem));
 105     if (!WorkItem) KeBugCheck(0);
 106     ObReferenceObject(FileObject);
 107     WorkItem->FileObject = FileObject;
 108     WorkItem->FileOffset = *FileOffset;
 109     WorkItem->Length = Length;
 110
 111     ExInitializeWorkItem(&WorkItem->WorkItem,
 112                          (PWORKER_THREAD_ROUTINE)CcpReadAhead,
 113                          WorkItem);
 114
 115     ExQueueWorkItem(&WorkItem->WorkItem, DelayedWorkQueue);
 116     DPRINT("Done\n");
 117 }
 118
 119 VOID
 120 NTAPI
 121 CcSetDirtyPinnedData(IN PVOID BcbVoid,
 122                      IN OPTIONAL PLARGE_INTEGER Lsn)
 123 {
 124     PNOCC_BCB Bcb = (PNOCC_BCB)BcbVoid;
 125     Bcb->Dirty = TRUE;
 126 }
 127
 128 LARGE_INTEGER
 129 NTAPI
 130 CcGetFlushedValidData(IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
 131                       IN BOOLEAN CcInternalCaller)
 132 {
 133     LARGE_INTEGER Result = {{0}};
 134     UNIMPLEMENTED_DBGBREAK();
 135     return Result;
 136 }
 137
 138
 139
 140 VOID
 141 NTAPI
 142 _CcpFlushCache(IN PNOCC_CACHE_MAP Map,
 143                IN OPTIONAL PLARGE_INTEGER FileOffset,
 144                IN ULONG Length,
 145                OUT OPTIONAL PIO_STATUS_BLOCK IoStatus,
 146                BOOLEAN Delete,
 147                const char *File,
 148                int Line)
 149 {
 150     PNOCC_BCB Bcb = NULL;
 151     LARGE_INTEGER LowerBound, UpperBound;
 152     PLIST_ENTRY ListEntry;
 153     IO_STATUS_BLOCK IOSB;
 154
 155     RtlZeroMemory(&IOSB, sizeof(IO_STATUS_BLOCK));
 156
 157     DPRINT("CcFlushCache (while file) (%s:%d)\n", File, Line);
 158
 159     if (FileOffset && Length)
 160     {
 161         LowerBound.QuadPart = FileOffset->QuadPart;
 162         UpperBound.QuadPart = LowerBound.QuadPart + Length;
 163     }
 164     else
 165     {
 166         LowerBound.QuadPart = 0;
 167         UpperBound.QuadPart = 0x7fffffffffffffffull;
 168     }
 169
 170     CcpLock();
 171     ListEntry = Map->AssociatedBcb.Flink;
 172
 173     while (ListEntry != &Map->AssociatedBcb)
 174     {
 175         Bcb = CONTAINING_RECORD(ListEntry, NOCC_BCB, ThisFileList);
 176         CcpReferenceCache((ULONG)(Bcb - CcCacheSections));
 177
 178         if (Bcb->FileOffset.QuadPart + Bcb->Length >= LowerBound.QuadPart &&
 179             Bcb->FileOffset.QuadPart < UpperBound.QuadPart)
 180         {
 181             DPRINT("Bcb #%x (@%08x%08x)\n",
 182                    Bcb - CcCacheSections,
 183                    Bcb->FileOffset.u.HighPart, Bcb->FileOffset.u.LowPart);
 184
 185             Bcb->RefCount++;
 186             CcpUnlock();
 187             MiFlushMappedSection(Bcb->BaseAddress,
 188                                  &Bcb->FileOffset,
 189                                  &Map->FileSizes.FileSize,
 190                                  Bcb->Dirty);
 191             CcpLock();
 192             Bcb->RefCount--;
 193
 194             Bcb->Dirty = FALSE;
 195
 196             ListEntry = ListEntry->Flink;
 197             if (Delete && Bcb->RefCount < 2)
 198             {
 199                 Bcb->RefCount = 1;
 200                 CcpDereferenceCache((ULONG)(Bcb - CcCacheSections), FALSE);
 201             }
 202             else
 203             {
 204                 CcpUnpinData(Bcb, TRUE);
 205             }
 206         }
 207         else
 208         {
 209             ListEntry = ListEntry->Flink;
 210             CcpUnpinData(Bcb, TRUE);
 211         }
 212
 213         DPRINT("End loop\n");
 214     }
 215     CcpUnlock();
 216
 217     if (IoStatus) *IoStatus = IOSB;
 218 }
 219
 220 VOID
 221 NTAPI
 222 CcFlushCache(IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
 223              IN OPTIONAL PLARGE_INTEGER FileOffset,
 224              IN ULONG Length,
 225              OUT OPTIONAL PIO_STATUS_BLOCK IoStatus)
 226 {
 227     PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap;
 228
 229     /* Not cached */
 230     if (!Map)
 231     {
 232         if (IoStatus)
 233         {
 234             IoStatus->Status = STATUS_SUCCESS;
 235             IoStatus->Information = 0;
 236         }
 237         return;
 238     }
 239
 240     CcpFlushCache(Map, FileOffset, Length, IoStatus, TRUE);
 241 }
 242
 243 BOOLEAN
 244 NTAPI
 245 CcFlushImageSection(PSECTION_OBJECT_POINTERS SectionObjectPointer,
 246                     MMFLUSH_TYPE FlushType)
 247 {
 248     PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap;
 249     PNOCC_BCB Bcb;
 250     PLIST_ENTRY Entry;
 251     IO_STATUS_BLOCK IOSB;
 252     BOOLEAN Result = TRUE;
 253
 254     if (!Map) return TRUE;
 255
 256     for (Entry = Map->AssociatedBcb.Flink;
 257          Entry != &Map->AssociatedBcb;
 258          Entry = Entry->Flink)
 259     {
 260         Bcb = CONTAINING_RECORD(Entry, NOCC_BCB, ThisFileList);
 261
 262         if (!Bcb->Dirty) continue;
 263
 264         switch (FlushType)
 265         {
 266             case MmFlushForDelete:
 267                 CcPurgeCacheSection(SectionObjectPointer,
 268                                     &Bcb->FileOffset,
 269                                     Bcb->Length,
 270                                     FALSE);
 271                 break;
 272             case MmFlushForWrite:
 273                 CcFlushCache(SectionObjectPointer,
 274                              &Bcb->FileOffset,
 275                              Bcb->Length,
 276                              &IOSB);
 277                 break;
 278         }
 279     }
 280
 281     return Result;
 282 }
 283
 284 /* Always succeeds for us */
 285 PVOID
 286 NTAPI
 287 CcRemapBcb(IN PVOID Bcb)
 288 {
 289     ULONG Number = (ULONG)(((PNOCC_BCB)Bcb) - CcCacheSections);
 290     CcpLock();
 291     ASSERT(RtlTestBit(CcCacheBitmap, Number));
 292     CcpReferenceCache(Number);
 293     CcpUnlock();
 294     return Bcb;
 295 }
 296
 297 VOID
 298 NTAPI
 299 CcShutdownSystem(VOID)
 300 {
 301     ULONG i, Result;
 302     NTSTATUS Status;
 303
 304     DPRINT1("CC: Shutdown\n");
 305
 306     for (i = 0; i < CACHE_NUM_SECTIONS; i++)
 307     {
 308         PNOCC_BCB Bcb = &CcCacheSections[i];
 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 }
 327
 328
 329 VOID
 330 NTAPI
 331 CcRepinBcb(IN PVOID Bcb)
 332 {
 333     ULONG Number = (ULONG)(((PNOCC_BCB)Bcb) - CcCacheSections);
 334     CcpLock();
 335     ASSERT(RtlTestBit(CcCacheBitmap, Number));
 336     DPRINT("CcRepinBcb(#%x)\n", Number);
 337     CcpReferenceCache(Number);
 338     CcpUnlock();
 339 }
 340
 341 VOID
 342 NTAPI
 343 CcUnpinRepinnedBcb(IN PVOID Bcb,
 344                    IN BOOLEAN WriteThrough,
 345                    OUT PIO_STATUS_BLOCK IoStatus)
 346 {
 347     PNOCC_BCB RealBcb = (PNOCC_BCB)Bcb;
 348
 349     if (WriteThrough)
 350     {
 351         DPRINT("BCB #%x\n", RealBcb - CcCacheSections);
 352
 353         CcpFlushCache(RealBcb->Map,
 354                       &RealBcb->FileOffset,
 355                       RealBcb->Length,
 356                       IoStatus,
 357                       RealBcb->Dirty);
 358     }
 359
 360     CcUnpinData(Bcb);
 361 }
 362
 363 /* EOF */