reactos/ntoskrnl/cc/view.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS kernel
   4  * FILE:            ntoskrnl/cc/view.c
   5  * PURPOSE:         Cache manager
   6  *
   7  * PROGRAMMERS:     David Welch (welch@mcmail.com)
   8  */
   9
  10 /* NOTES **********************************************************************
  11  *
  12  * This is not the NT implementation of a file cache nor anything much like
  13  * it.
  14  *
  15  * The general procedure for a filesystem to implement a read or write
  16  * dispatch routine is as follows
  17  *
  18  * (1) If caching for the FCB hasn't been initiated then so do by calling
  19  * CcInitializeFileCache.
  20  *
  21  * (2) For each 4k region which is being read or written obtain a cache page
  22  * by calling CcRequestCachePage.
  23  *
  24  * (3) If either the page is being read or not completely written, and it is
  25  * not up to date then read its data from the underlying medium. If the read
  26  * fails then call CcReleaseCachePage with VALID as FALSE and return a error.
  27  *
  28  * (4) Copy the data into or out of the page as necessary.
  29  *
  30  * (5) Release the cache page
  31  */
  32 /* INCLUDES ******************************************************************/
  33
  34 #include <ntoskrnl.h>
  35 #define NDEBUG
  36 #include <debug.h>
  37
  38 #if defined (ALLOC_PRAGMA)
  39 #pragma alloc_text(INIT, CcInitView)
  40 #endif
  41
  42 /* GLOBALS *******************************************************************/
  43
  44 static LIST_ENTRY DirtyVacbListHead;
  45 static LIST_ENTRY VacbLruListHead;
  46 ULONG DirtyPageCount = 0;
  47
  48 KGUARDED_MUTEX ViewLock;
  49
  50 NPAGED_LOOKASIDE_LIST iBcbLookasideList;
  51 static NPAGED_LOOKASIDE_LIST SharedCacheMapLookasideList;
  52 static NPAGED_LOOKASIDE_LIST VacbLookasideList;
  53
  54 #if DBG
  55 static void CcRosVacbIncRefCount_(PROS_VACB vacb, const char* file, int line)
  56 {
  57     ++vacb->ReferenceCount;
  58     if (vacb->SharedCacheMap->Trace)
  59     {
  60         DbgPrint("(%s:%i) VACB %p ++RefCount=%lu, Dirty %u, PageOut %lu\n",
  61                  file, line, vacb, vacb->ReferenceCount, vacb->Dirty, vacb->PageOut);
  62     }
  63 }
  64 static void CcRosVacbDecRefCount_(PROS_VACB vacb, const char* file, int line)
  65 {
  66     --vacb->ReferenceCount;
  67     if (vacb->SharedCacheMap->Trace)
  68     {
  69         DbgPrint("(%s:%i) VACB %p --RefCount=%lu, Dirty %u, PageOut %lu\n",
  70                  file, line, vacb, vacb->ReferenceCount, vacb->Dirty, vacb->PageOut);
  71     }
  72 }
  73 #define CcRosVacbIncRefCount(vacb) CcRosVacbIncRefCount_(vacb,__FILE__,__LINE__)
  74 #define CcRosVacbDecRefCount(vacb) CcRosVacbDecRefCount_(vacb,__FILE__,__LINE__)
  75 #else
  76 #define CcRosVacbIncRefCount(vacb) (++((vacb)->ReferenceCount))
  77 #define CcRosVacbDecRefCount(vacb) (--((vacb)->ReferenceCount))
  78 #endif
  79
  80 NTSTATUS
  81 CcRosInternalFreeVacb(PROS_VACB Vacb);
  82
  83
  84 /* FUNCTIONS *****************************************************************/
  85
  86 VOID
  87 NTAPI
  88 CcRosTraceCacheMap (
  89     PROS_SHARED_CACHE_MAP SharedCacheMap,
  90     BOOLEAN Trace )
  91 {
  92 #if DBG
  93     KIRQL oldirql;
  94     PLIST_ENTRY current_entry;
  95     PROS_VACB current;
  96
  97     if (!SharedCacheMap)
  98         return;
  99
 100     SharedCacheMap->Trace = Trace;
 101
 102     if (Trace)
 103     {
 104         DPRINT1("Enabling Tracing for CacheMap 0x%p:\n", SharedCacheMap);
 105
 106         KeAcquireGuardedMutex(&ViewLock);
 107         KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldirql);
 108
 109         current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
 110         while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
 111         {
 112             current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
 113             current_entry = current_entry->Flink;
 114
 115             DPRINT1("  VACB 0x%p enabled, RefCount %lu, Dirty %u, PageOut %lu\n",
 116                     current, current->ReferenceCount, current->Dirty, current->PageOut );
 117         }
 118         KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
 119         KeReleaseGuardedMutex(&ViewLock);
 120     }
 121     else
 122     {
 123         DPRINT1("Disabling Tracing for CacheMap 0x%p:\n", SharedCacheMap);
 124     }
 125
 126 #else
 127     UNREFERENCED_PARAMETER(SharedCacheMap);
 128     UNREFERENCED_PARAMETER(Trace);
 129 #endif
 130 }
 131
 132 NTSTATUS
 133 NTAPI
 134 CcRosFlushVacb (
 135     PROS_VACB Vacb)
 136 {
 137     NTSTATUS Status;
 138     KIRQL oldIrql;
 139
 140     Status = CcWriteVirtualAddress(Vacb);
 141     if (NT_SUCCESS(Status))
 142     {
 143         KeAcquireGuardedMutex(&ViewLock);
 144         KeAcquireSpinLock(&Vacb->SharedCacheMap->CacheMapLock, &oldIrql);
 145
 146         Vacb->Dirty = FALSE;
 147         RemoveEntryList(&Vacb->DirtyVacbListEntry);
 148         DirtyPageCount -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
 149         CcRosVacbDecRefCount(Vacb);
 150
 151         KeReleaseSpinLock(&Vacb->SharedCacheMap->CacheMapLock, oldIrql);
 152         KeReleaseGuardedMutex(&ViewLock);
 153     }
 154
 155     return Status;
 156 }
 157
 158 NTSTATUS
 159 NTAPI
 160 CcRosFlushDirtyPages (
 161     ULONG Target,
 162     PULONG Count,
 163     BOOLEAN Wait)
 164 {
 165     PLIST_ENTRY current_entry;
 166     PROS_VACB current;
 167     BOOLEAN Locked;
 168     NTSTATUS Status;
 169     LARGE_INTEGER ZeroTimeout;
 170
 171     DPRINT("CcRosFlushDirtyPages(Target %lu)\n", Target);
 172
 173     (*Count) = 0;
 174     ZeroTimeout.QuadPart = 0;
 175
 176     KeEnterCriticalRegion();
 177     KeAcquireGuardedMutex(&ViewLock);
 178
 179     current_entry = DirtyVacbListHead.Flink;
 180     if (current_entry == &DirtyVacbListHead)
 181     {
 182         DPRINT("No Dirty pages\n");
 183     }
 184
 185     while ((current_entry != &DirtyVacbListHead) && (Target > 0))
 186     {
 187         current = CONTAINING_RECORD(current_entry,
 188                                     ROS_VACB,
 189                                     DirtyVacbListEntry);
 190         current_entry = current_entry->Flink;
 191
 192         CcRosVacbIncRefCount(current);
 193
 194         Locked = current->SharedCacheMap->Callbacks->AcquireForLazyWrite(
 195                      current->SharedCacheMap->LazyWriteContext, Wait);
 196         if (!Locked)
 197         {
 198             CcRosVacbDecRefCount(current);
 199             continue;
 200         }
 201
 202         Status = KeWaitForSingleObject(&current->Mutex,
 203                                        Executive,
 204                                        KernelMode,
 205                                        FALSE,
 206                                        Wait ? NULL : &ZeroTimeout);
 207         if (Status != STATUS_SUCCESS)
 208         {
 209             current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
 210                 current->SharedCacheMap->LazyWriteContext);
 211             CcRosVacbDecRefCount(current);
 212             continue;
 213         }
 214
 215         ASSERT(current->Dirty);
 216
 217         /* One reference is added above */
 218         if (current->ReferenceCount > 2)
 219         {
 220             KeReleaseMutex(&current->Mutex, FALSE);
 221             current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
 222                 current->SharedCacheMap->LazyWriteContext);
 223             CcRosVacbDecRefCount(current);
 224             continue;
 225         }
 226
 227         KeReleaseGuardedMutex(&ViewLock);
 228
 229         Status = CcRosFlushVacb(current);
 230
 231         KeReleaseMutex(&current->Mutex, FALSE);
 232         current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
 233             current->SharedCacheMap->LazyWriteContext);
 234
 235         KeAcquireGuardedMutex(&ViewLock);
 236         CcRosVacbDecRefCount(current);
 237
 238         if (!NT_SUCCESS(Status) &&  (Status != STATUS_END_OF_FILE))
 239         {
 240             DPRINT1("CC: Failed to flush VACB.\n");
 241         }
 242         else
 243         {
 244             (*Count) += VACB_MAPPING_GRANULARITY / PAGE_SIZE;
 245             Target -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
 246         }
 247
 248         current_entry = DirtyVacbListHead.Flink;
 249     }
 250
 251     KeReleaseGuardedMutex(&ViewLock);
 252     KeLeaveCriticalRegion();
 253
 254     DPRINT("CcRosFlushDirtyPages() finished\n");
 255     return STATUS_SUCCESS;
 256 }
 257
 258 NTSTATUS
 259 CcRosTrimCache (
 260     ULONG Target,
 261     ULONG Priority,
 262     PULONG NrFreed)
 263 /*
 264  * FUNCTION: Try to free some memory from the file cache.
 265  * ARGUMENTS:
 266  *       Target - The number of pages to be freed.
 267  *       Priority - The priority of free (currently unused).
 268  *       NrFreed - Points to a variable where the number of pages
 269  *                 actually freed is returned.
 270  */
 271 {
 272     PLIST_ENTRY current_entry;
 273     PROS_VACB current;
 274     ULONG PagesFreed;
 275     KIRQL oldIrql;
 276     LIST_ENTRY FreeList;
 277     PFN_NUMBER Page;
 278     ULONG i;
 279     BOOLEAN FlushedPages = FALSE;
 280
 281     DPRINT("CcRosTrimCache(Target %lu)\n", Target);
 282
 283     InitializeListHead(&FreeList);
 284
 285     *NrFreed = 0;
 286
 287 retry:
 288     KeAcquireGuardedMutex(&ViewLock);
 289
 290     current_entry = VacbLruListHead.Flink;
 291     while (current_entry != &VacbLruListHead)
 292     {
 293         current = CONTAINING_RECORD(current_entry,
 294                                     ROS_VACB,
 295                                     VacbLruListEntry);
 296         current_entry = current_entry->Flink;
 297
 298         KeAcquireSpinLock(&current->SharedCacheMap->CacheMapLock, &oldIrql);
 299
 300         /* Reference the VACB */
 301         CcRosVacbIncRefCount(current);
 302
 303         /* Check if it's mapped and not dirty */
 304         if (current->MappedCount > 0 && !current->Dirty)
 305         {
 306             /* We have to break these locks because Cc sucks */
 307             KeReleaseSpinLock(&current->SharedCacheMap->CacheMapLock, oldIrql);
 308             KeReleaseGuardedMutex(&ViewLock);
 309
 310             /* Page out the VACB */
 311             for (i = 0; i < VACB_MAPPING_GRANULARITY / PAGE_SIZE; i++)
 312             {
 313                 Page = (PFN_NUMBER)(MmGetPhysicalAddress((PUCHAR)current->BaseAddress + (i * PAGE_SIZE)).QuadPart >> PAGE_SHIFT);
 314
 315                 MmPageOutPhysicalAddress(Page);
 316             }
 317
 318             /* Reacquire the locks */
 319             KeAcquireGuardedMutex(&ViewLock);
 320             KeAcquireSpinLock(&current->SharedCacheMap->CacheMapLock, &oldIrql);
 321         }
 322
 323         /* Dereference the VACB */
 324         CcRosVacbDecRefCount(current);
 325
 326         /* Check if we can free this entry now */
 327         if (current->ReferenceCount == 0)
 328         {
 329             ASSERT(!current->Dirty);
 330             ASSERT(!current->MappedCount);
 331
 332             RemoveEntryList(&current->CacheMapVacbListEntry);
 333             RemoveEntryList(&current->VacbLruListEntry);
 334             InsertHeadList(&FreeList, &current->CacheMapVacbListEntry);
 335
 336             /* Calculate how many pages we freed for Mm */
 337             PagesFreed = min(VACB_MAPPING_GRANULARITY / PAGE_SIZE, Target);
 338             Target -= PagesFreed;
 339             (*NrFreed) += PagesFreed;
 340         }
 341
 342         KeReleaseSpinLock(&current->SharedCacheMap->CacheMapLock, oldIrql);
 343     }
 344
 345     KeReleaseGuardedMutex(&ViewLock);
 346
 347     /* Try flushing pages if we haven't met our target */
 348     if ((Target > 0) && !FlushedPages)
 349     {
 350         /* Flush dirty pages to disk */
 351         CcRosFlushDirtyPages(Target, &PagesFreed, FALSE);
 352         FlushedPages = TRUE;
 353
 354         /* We can only swap as many pages as we flushed */
 355         if (PagesFreed < Target) Target = PagesFreed;
 356
 357         /* Check if we flushed anything */
 358         if (PagesFreed != 0)
 359         {
 360             /* Try again after flushing dirty pages */
 361             DPRINT("Flushed %lu dirty cache pages to disk\n", PagesFreed);
 362             goto retry;
 363         }
 364     }
 365
 366     while (!IsListEmpty(&FreeList))
 367     {
 368         current_entry = RemoveHeadList(&FreeList);
 369         current = CONTAINING_RECORD(current_entry,
 370                                     ROS_VACB,
 371                                     CacheMapVacbListEntry);
 372         CcRosInternalFreeVacb(current);
 373     }
 374
 375     DPRINT("Evicted %lu cache pages\n", (*NrFreed));
 376
 377     return STATUS_SUCCESS;
 378 }
 379
 380 NTSTATUS
 381 NTAPI
 382 CcRosReleaseVacb (
 383     PROS_SHARED_CACHE_MAP SharedCacheMap,
 384     PROS_VACB Vacb,
 385     BOOLEAN Valid,
 386     BOOLEAN Dirty,
 387     BOOLEAN Mapped)
 388 {
 389     BOOLEAN WasDirty;
 390     KIRQL oldIrql;
 391
 392     ASSERT(SharedCacheMap);
 393
 394     DPRINT("CcRosReleaseVacb(SharedCacheMap 0x%p, Vacb 0x%p, Valid %u)\n",
 395            SharedCacheMap, Vacb, Valid);
 396
 397     KeAcquireGuardedMutex(&ViewLock);
 398     KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
 399
 400     Vacb->Valid = Valid;
 401
 402     WasDirty = Vacb->Dirty;
 403     Vacb->Dirty = Vacb->Dirty || Dirty;
 404
 405     if (!WasDirty && Vacb->Dirty)
 406     {
 407         InsertTailList(&DirtyVacbListHead, &Vacb->DirtyVacbListEntry);
 408         DirtyPageCount += VACB_MAPPING_GRANULARITY / PAGE_SIZE;
 409     }
 410
 411     if (Mapped)
 412     {
 413         Vacb->MappedCount++;
 414     }
 415     CcRosVacbDecRefCount(Vacb);
 416     if (Mapped && (Vacb->MappedCount == 1))
 417     {
 418         CcRosVacbIncRefCount(Vacb);
 419     }
 420     if (!WasDirty && Vacb->Dirty)
 421     {
 422         CcRosVacbIncRefCount(Vacb);
 423     }
 424
 425     KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
 426     KeReleaseGuardedMutex(&ViewLock);
 427     KeReleaseMutex(&Vacb->Mutex, FALSE);
 428
 429     return STATUS_SUCCESS;
 430 }
 431
 432 /* Returns with VACB Lock Held! */
 433 PROS_VACB
 434 NTAPI
 435 CcRosLookupVacb (
 436     PROS_SHARED_CACHE_MAP SharedCacheMap,
 437     LONGLONG FileOffset)
 438 {
 439     PLIST_ENTRY current_entry;
 440     PROS_VACB current;
 441     KIRQL oldIrql;
 442
 443     ASSERT(SharedCacheMap);
 444
 445     DPRINT("CcRosLookupVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
 446            SharedCacheMap, FileOffset);
 447
 448     KeAcquireGuardedMutex(&ViewLock);
 449     KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
 450
 451     current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
 452     while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
 453     {
 454         current = CONTAINING_RECORD(current_entry,
 455                                     ROS_VACB,
 456                                     CacheMapVacbListEntry);
 457         if (IsPointInRange(current->FileOffset.QuadPart,
 458                            VACB_MAPPING_GRANULARITY,
 459                            FileOffset))
 460         {
 461             CcRosVacbIncRefCount(current);
 462             KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
 463             KeReleaseGuardedMutex(&ViewLock);
 464             KeWaitForSingleObject(&current->Mutex,
 465                                   Executive,
 466                                   KernelMode,
 467                                   FALSE,
 468                                   NULL);
 469             return current;
 470         }
 471         if (current->FileOffset.QuadPart > FileOffset)
 472             break;
 473         current_entry = current_entry->Flink;
 474     }
 475
 476     KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
 477     KeReleaseGuardedMutex(&ViewLock);
 478
 479     return NULL;
 480 }
 481
 482 NTSTATUS
 483 NTAPI
 484 CcRosMarkDirtyVacb (
 485     PROS_SHARED_CACHE_MAP SharedCacheMap,
 486     LONGLONG FileOffset)
 487 {
 488     PROS_VACB Vacb;
 489     KIRQL oldIrql;
 490
 491     ASSERT(SharedCacheMap);
 492
 493     DPRINT("CcRosMarkDirtyVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
 494            SharedCacheMap, FileOffset);
 495
 496     Vacb = CcRosLookupVacb(SharedCacheMap, FileOffset);
 497     if (Vacb == NULL)
 498     {
 499         KeBugCheck(CACHE_MANAGER);
 500     }
 501
 502     KeAcquireGuardedMutex(&ViewLock);
 503     KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
 504
 505     if (!Vacb->Dirty)
 506     {
 507         InsertTailList(&DirtyVacbListHead, &Vacb->DirtyVacbListEntry);
 508         DirtyPageCount += VACB_MAPPING_GRANULARITY / PAGE_SIZE;
 509     }
 510     else
 511     {
 512         CcRosVacbDecRefCount(Vacb);
 513     }
 514
 515     /* Move to the tail of the LRU list */
 516     RemoveEntryList(&Vacb->VacbLruListEntry);
 517     InsertTailList(&VacbLruListHead, &Vacb->VacbLruListEntry);
 518
 519     Vacb->Dirty = TRUE;
 520
 521     KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
 522     KeReleaseGuardedMutex(&ViewLock);
 523     KeReleaseMutex(&Vacb->Mutex, FALSE);
 524
 525     return STATUS_SUCCESS;
 526 }
 527
 528 NTSTATUS
 529 NTAPI
 530 CcRosUnmapVacb (
 531     PROS_SHARED_CACHE_MAP SharedCacheMap,
 532     LONGLONG FileOffset,
 533     BOOLEAN NowDirty)
 534 {
 535     PROS_VACB Vacb;
 536     BOOLEAN WasDirty;
 537     KIRQL oldIrql;
 538
 539     ASSERT(SharedCacheMap);
 540
 541     DPRINT("CcRosUnmapVacb(SharedCacheMap 0x%p, FileOffset %I64u, NowDirty %u)\n",
 542            SharedCacheMap, FileOffset, NowDirty);
 543
 544     Vacb = CcRosLookupVacb(SharedCacheMap, FileOffset);
 545     if (Vacb == NULL)
 546     {
 547         return STATUS_UNSUCCESSFUL;
 548     }
 549
 550     KeAcquireGuardedMutex(&ViewLock);
 551     KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
 552
 553     WasDirty = Vacb->Dirty;
 554     Vacb->Dirty = Vacb->Dirty || NowDirty;
 555
 556     Vacb->MappedCount--;
 557
 558     if (!WasDirty && NowDirty)
 559     {
 560         InsertTailList(&DirtyVacbListHead, &Vacb->DirtyVacbListEntry);
 561         DirtyPageCount += VACB_MAPPING_GRANULARITY / PAGE_SIZE;
 562     }
 563
 564     CcRosVacbDecRefCount(Vacb);
 565     if (!WasDirty && NowDirty)
 566     {
 567         CcRosVacbIncRefCount(Vacb);
 568     }
 569     if (Vacb->MappedCount == 0)
 570     {
 571         CcRosVacbDecRefCount(Vacb);
 572     }
 573
 574     KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
 575     KeReleaseGuardedMutex(&ViewLock);
 576     KeReleaseMutex(&Vacb->Mutex, FALSE);
 577
 578     return STATUS_SUCCESS;
 579 }
 580
 581 static
 582 NTSTATUS
 583 CcRosMapVacb(
 584     PROS_VACB Vacb)
 585 {
 586     ULONG i;
 587     NTSTATUS Status;
 588     ULONG_PTR NumberOfPages;
 589
 590     /* Create a memory area. */
 591     MmLockAddressSpace(MmGetKernelAddressSpace());
 592     Status = MmCreateMemoryArea(MmGetKernelAddressSpace(),
 593                                 0, // nothing checks for VACB mareas, so set to 0
 594                                 &Vacb->BaseAddress,
 595                                 VACB_MAPPING_GRANULARITY,
 596                                 PAGE_READWRITE,
 597                                 (PMEMORY_AREA*)&Vacb->MemoryArea,
 598                                 0,
 599                                 PAGE_SIZE);
 600     MmUnlockAddressSpace(MmGetKernelAddressSpace());
 601     if (!NT_SUCCESS(Status))
 602     {
 603         KeBugCheck(CACHE_MANAGER);
 604     }
 605
 606     ASSERT(((ULONG_PTR)Vacb->BaseAddress % PAGE_SIZE) == 0);
 607     ASSERT((ULONG_PTR)Vacb->BaseAddress > (ULONG_PTR)MmSystemRangeStart);
 608
 609     /* Create a virtual mapping for this memory area */
 610     NumberOfPages = BYTES_TO_PAGES(VACB_MAPPING_GRANULARITY);
 611     for (i = 0; i < NumberOfPages; i++)
 612     {
 613         PFN_NUMBER PageFrameNumber;
 614
 615         Status = MmRequestPageMemoryConsumer(MC_CACHE, TRUE, &PageFrameNumber);
 616         if (PageFrameNumber == 0)
 617         {
 618             DPRINT1("Unable to allocate page\n");
 619             KeBugCheck(MEMORY_MANAGEMENT);
 620         }
 621
 622         Status = MmCreateVirtualMapping(NULL,
 623                                         (PVOID)((ULONG_PTR)Vacb->BaseAddress + (i * PAGE_SIZE)),
 624                                         PAGE_READWRITE,
 625                                         &PageFrameNumber,
 626                                         1);
 627         if (!NT_SUCCESS(Status))
 628         {
 629             DPRINT1("Unable to create virtual mapping\n");
 630             KeBugCheck(MEMORY_MANAGEMENT);
 631         }
 632     }
 633
 634     return STATUS_SUCCESS;
 635 }
 636
 637 static
 638 NTSTATUS
 639 CcRosCreateVacb (
 640     PROS_SHARED_CACHE_MAP SharedCacheMap,
 641     LONGLONG FileOffset,
 642     PROS_VACB *Vacb)
 643 {
 644     PROS_VACB current;
 645     PROS_VACB previous;
 646     PLIST_ENTRY current_entry;
 647     NTSTATUS Status;
 648     KIRQL oldIrql;
 649
 650     ASSERT(SharedCacheMap);
 651
 652     DPRINT("CcRosCreateVacb()\n");
 653
 654     if (FileOffset >= SharedCacheMap->FileSize.QuadPart)
 655     {
 656         *Vacb = NULL;
 657         return STATUS_INVALID_PARAMETER;
 658     }
 659
 660     current = ExAllocateFromNPagedLookasideList(&VacbLookasideList);
 661     current->BaseAddress = NULL;
 662     current->Valid = FALSE;
 663     current->Dirty = FALSE;
 664     current->PageOut = FALSE;
 665     current->FileOffset.QuadPart = ROUND_DOWN(FileOffset, VACB_MAPPING_GRANULARITY);
 666     current->SharedCacheMap = SharedCacheMap;
 667 #if DBG
 668     if (SharedCacheMap->Trace)
 669     {
 670         DPRINT1("CacheMap 0x%p: new VACB: 0x%p\n", SharedCacheMap, current);
 671     }
 672 #endif
 673     current->MappedCount = 0;
 674     current->DirtyVacbListEntry.Flink = NULL;
 675     current->DirtyVacbListEntry.Blink = NULL;
 676     current->ReferenceCount = 1;
 677     KeInitializeMutex(&current->Mutex, 0);
 678     KeWaitForSingleObject(&current->Mutex,
 679                           Executive,
 680                           KernelMode,
 681                           FALSE,
 682                           NULL);
 683     KeAcquireGuardedMutex(&ViewLock);
 684
 685     *Vacb = current;
 686     /* There is window between the call to CcRosLookupVacb
 687      * and CcRosCreateVacb. We must check if a VACB for the
 688      * file offset exist. If there is a VACB, we release
 689      * our newly created VACB and return the existing one.
 690      */
 691     KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
 692     current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
 693     previous = NULL;
 694     while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
 695     {
 696         current = CONTAINING_RECORD(current_entry,
 697                                     ROS_VACB,
 698                                     CacheMapVacbListEntry);
 699         if (IsPointInRange(current->FileOffset.QuadPart,
 700                            VACB_MAPPING_GRANULARITY,
 701                            FileOffset))
 702         {
 703             CcRosVacbIncRefCount(current);
 704             KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
 705 #if DBG
 706             if (SharedCacheMap->Trace)
 707             {
 708                 DPRINT1("CacheMap 0x%p: deleting newly created VACB 0x%p ( found existing one 0x%p )\n",
 709                         SharedCacheMap,
 710                         (*Vacb),
 711                         current);
 712             }
 713 #endif
 714             KeReleaseMutex(&(*Vacb)->Mutex, FALSE);
 715             KeReleaseGuardedMutex(&ViewLock);
 716             ExFreeToNPagedLookasideList(&VacbLookasideList, *Vacb);
 717             *Vacb = current;
 718             KeWaitForSingleObject(&current->Mutex,
 719                                   Executive,
 720                                   KernelMode,
 721                                   FALSE,
 722                                   NULL);
 723             return STATUS_SUCCESS;
 724         }
 725         if (current->FileOffset.QuadPart < FileOffset)
 726         {
 727             ASSERT(previous == NULL ||
 728                    previous->FileOffset.QuadPart < current->FileOffset.QuadPart);
 729             previous = current;
 730         }
 731         if (current->FileOffset.QuadPart > FileOffset)
 732             break;
 733         current_entry = current_entry->Flink;
 734     }
 735     /* There was no existing VACB. */
 736     current = *Vacb;
 737     if (previous)
 738     {
 739         InsertHeadList(&previous->CacheMapVacbListEntry, &current->CacheMapVacbListEntry);
 740     }
 741     else
 742     {
 743         InsertHeadList(&SharedCacheMap->CacheMapVacbListHead, &current->CacheMapVacbListEntry);
 744     }
 745     KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
 746     InsertTailList(&VacbLruListHead, &current->VacbLruListEntry);
 747     KeReleaseGuardedMutex(&ViewLock);
 748
 749     MI_SET_USAGE(MI_USAGE_CACHE);
 750 #if MI_TRACE_PFNS
 751     if ((SharedCacheMap->FileObject) && (SharedCacheMap->FileObject->FileName.Buffer))
 752     {
 753         PWCHAR pos = NULL;
 754         ULONG len = 0;
 755         pos = wcsrchr(SharedCacheMap->FileObject->FileName.Buffer, '\\');
 756         len = wcslen(pos) * sizeof(WCHAR);
 757         if (pos) snprintf(MI_PFN_CURRENT_PROCESS_NAME, min(16, len), "%S", pos);
 758     }
 759 #endif
 760
 761     Status = CcRosMapVacb(current);
 762
 763     return Status;
 764 }
 765
 766 NTSTATUS
 767 NTAPI
 768 CcRosGetVacb (
 769     PROS_SHARED_CACHE_MAP SharedCacheMap,
 770     LONGLONG FileOffset,
 771     PLONGLONG BaseOffset,
 772     PVOID* BaseAddress,
 773     PBOOLEAN UptoDate,
 774     PROS_VACB *Vacb)
 775 {
 776     PROS_VACB current;
 777     NTSTATUS Status;
 778
 779     ASSERT(SharedCacheMap);
 780
 781     DPRINT("CcRosGetVacb()\n");
 782
 783     /*
 784      * Look for a VACB already mapping the same data.
 785      */
 786     current = CcRosLookupVacb(SharedCacheMap, FileOffset);
 787     if (current == NULL)
 788     {
 789         /*
 790          * Otherwise create a new VACB.
 791          */
 792         Status = CcRosCreateVacb(SharedCacheMap, FileOffset, &current);
 793         if (!NT_SUCCESS(Status))
 794         {
 795             return Status;
 796         }
 797     }
 798
 799     KeAcquireGuardedMutex(&ViewLock);
 800
 801     /* Move to the tail of the LRU list */
 802     RemoveEntryList(&current->VacbLruListEntry);
 803     InsertTailList(&VacbLruListHead, &current->VacbLruListEntry);
 804
 805     KeReleaseGuardedMutex(&ViewLock);
 806
 807     /*
 808      * Return information about the VACB to the caller.
 809      */
 810     *UptoDate = current->Valid;
 811     *BaseAddress = current->BaseAddress;
 812     DPRINT("*BaseAddress %p\n", *BaseAddress);
 813     *Vacb = current;
 814     *BaseOffset = current->FileOffset.QuadPart;
 815     return STATUS_SUCCESS;
 816 }
 817
 818 NTSTATUS
 819 NTAPI
 820 CcRosRequestVacb (
 821     PROS_SHARED_CACHE_MAP SharedCacheMap,
 822     LONGLONG FileOffset,
 823     PVOID* BaseAddress,
 824     PBOOLEAN UptoDate,
 825     PROS_VACB *Vacb)
 826 /*
 827  * FUNCTION: Request a page mapping for a shared cache map
 828  */
 829 {
 830     LONGLONG BaseOffset;
 831
 832     ASSERT(SharedCacheMap);
 833
 834     if (FileOffset % VACB_MAPPING_GRANULARITY != 0)
 835     {
 836         DPRINT1("Bad fileoffset %I64x should be multiple of %x",
 837                 FileOffset, VACB_MAPPING_GRANULARITY);
 838         KeBugCheck(CACHE_MANAGER);
 839     }
 840
 841     return CcRosGetVacb(SharedCacheMap,
 842                         FileOffset,
 843                         &BaseOffset,
 844                         BaseAddress,
 845                         UptoDate,
 846                         Vacb);
 847 }
 848
 849 static
 850 VOID
 851 CcFreeCachePage (
 852     PVOID Context,
 853     MEMORY_AREA* MemoryArea,
 854     PVOID Address,
 855     PFN_NUMBER Page,
 856     SWAPENTRY SwapEntry,
 857     BOOLEAN Dirty)
 858 {
 859     ASSERT(SwapEntry == 0);
 860     if (Page != 0)
 861     {
 862         ASSERT(MmGetReferenceCountPage(Page) == 1);
 863         MmReleasePageMemoryConsumer(MC_CACHE, Page);
 864     }
 865 }
 866
 867 NTSTATUS
 868 CcRosInternalFreeVacb (
 869     PROS_VACB Vacb)
 870 /*
 871  * FUNCTION: Releases a VACB associated with a shared cache map
 872  */
 873 {
 874     DPRINT("Freeing VACB 0x%p\n", Vacb);
 875 #if DBG
 876     if (Vacb->SharedCacheMap->Trace)
 877     {
 878         DPRINT1("CacheMap 0x%p: deleting VACB: 0x%p\n", Vacb->SharedCacheMap, Vacb);
 879     }
 880 #endif
 881
 882     MmLockAddressSpace(MmGetKernelAddressSpace());
 883     MmFreeMemoryArea(MmGetKernelAddressSpace(),
 884                      Vacb->MemoryArea,
 885                      CcFreeCachePage,
 886                      NULL);
 887     MmUnlockAddressSpace(MmGetKernelAddressSpace());
 888
 889     ExFreeToNPagedLookasideList(&VacbLookasideList, Vacb);
 890     return STATUS_SUCCESS;
 891 }
 892
 893 /*
 894  * @implemented
 895  */
 896 VOID
 897 NTAPI
 898 CcFlushCache (
 899     IN PSECTION_OBJECT_POINTERS SectionObjectPointers,
 900     IN PLARGE_INTEGER FileOffset OPTIONAL,
 901     IN ULONG Length,
 902     OUT PIO_STATUS_BLOCK IoStatus)
 903 {
 904     PROS_SHARED_CACHE_MAP SharedCacheMap;
 905     LARGE_INTEGER Offset;
 906     LONGLONG RemainingLength;
 907     PROS_VACB current;
 908     NTSTATUS Status;
 909     KIRQL oldIrql;
 910
 911     CCTRACE(CC_API_DEBUG, "SectionObjectPointers=%p FileOffset=%p Length=%lu\n",
 912         SectionObjectPointers, FileOffset, Length);
 913
 914     DPRINT("CcFlushCache(SectionObjectPointers 0x%p, FileOffset 0x%p, Length %lu, IoStatus 0x%p)\n",
 915            SectionObjectPointers, FileOffset, Length, IoStatus);
 916
 917     if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
 918     {
 919         SharedCacheMap = SectionObjectPointers->SharedCacheMap;
 920         ASSERT(SharedCacheMap);
 921         if (FileOffset)
 922         {
 923             Offset = *FileOffset;
 924             RemainingLength = Length;
 925         }
 926         else
 927         {
 928             Offset.QuadPart = 0;
 929             RemainingLength = SharedCacheMap->FileSize.QuadPart;
 930         }
 931
 932         if (IoStatus)
 933         {
 934             IoStatus->Status = STATUS_SUCCESS;
 935             IoStatus->Information = 0;
 936         }
 937
 938         while (RemainingLength > 0)
 939         {
 940             current = CcRosLookupVacb(SharedCacheMap, Offset.QuadPart);
 941             if (current != NULL)
 942             {
 943                 if (current->Dirty)
 944                 {
 945                     Status = CcRosFlushVacb(current);
 946                     if (!NT_SUCCESS(Status) && IoStatus != NULL)
 947                     {
 948                         IoStatus->Status = Status;
 949                     }
 950                 }
 951                 KeReleaseMutex(&current->Mutex, FALSE);
 952
 953                 KeAcquireGuardedMutex(&ViewLock);
 954                 KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
 955                 CcRosVacbDecRefCount(current);
 956                 KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
 957                 KeReleaseGuardedMutex(&ViewLock);
 958             }
 959
 960             Offset.QuadPart += VACB_MAPPING_GRANULARITY;
 961             RemainingLength -= min(RemainingLength, VACB_MAPPING_GRANULARITY);
 962         }
 963     }
 964     else
 965     {
 966         if (IoStatus)
 967         {
 968             IoStatus->Status = STATUS_INVALID_PARAMETER;
 969         }
 970     }
 971 }
 972
 973 NTSTATUS
 974 NTAPI
 975 CcRosDeleteFileCache (
 976     PFILE_OBJECT FileObject,
 977     PROS_SHARED_CACHE_MAP SharedCacheMap)
 978 /*
 979  * FUNCTION: Releases the shared cache map associated with a file object
 980  */
 981 {
 982     PLIST_ENTRY current_entry;
 983     PROS_VACB current;
 984     LIST_ENTRY FreeList;
 985     KIRQL oldIrql;
 986
 987     ASSERT(SharedCacheMap);
 988
 989     SharedCacheMap->RefCount++;
 990     KeReleaseGuardedMutex(&ViewLock);
 991
 992     CcFlushCache(FileObject->SectionObjectPointer, NULL, 0, NULL);
 993
 994     KeAcquireGuardedMutex(&ViewLock);
 995     SharedCacheMap->RefCount--;
 996     if (SharedCacheMap->RefCount == 0)
 997     {
 998         FileObject->SectionObjectPointer->SharedCacheMap = NULL;
 999
1000         /*
1001          * Release all VACBs
1002          */
1003         InitializeListHead(&FreeList);
1004         KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
1005         while (!IsListEmpty(&SharedCacheMap->CacheMapVacbListHead))
1006         {
1007             current_entry = RemoveTailList(&SharedCacheMap->CacheMapVacbListHead);
1008             current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
1009             RemoveEntryList(&current->VacbLruListEntry);
1010             if (current->Dirty)
1011             {
1012                 RemoveEntryList(&current->DirtyVacbListEntry);
1013                 DirtyPageCount -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
1014                 DPRINT1("Freeing dirty VACB\n");
1015             }
1016             InsertHeadList(&FreeList, &current->CacheMapVacbListEntry);
1017         }
1018 #if DBG
1019         SharedCacheMap->Trace = FALSE;
1020 #endif
1021         KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
1022
1023         KeReleaseGuardedMutex(&ViewLock);
1024         ObDereferenceObject(SharedCacheMap->FileObject);
1025
1026         while (!IsListEmpty(&FreeList))
1027         {
1028             current_entry = RemoveTailList(&FreeList);
1029             current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
1030             CcRosInternalFreeVacb(current);
1031         }
1032         ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap);
1033         KeAcquireGuardedMutex(&ViewLock);
1034     }
1035     return STATUS_SUCCESS;
1036 }
1037
1038 VOID
1039 NTAPI
1040 CcRosReferenceCache (
1041     PFILE_OBJECT FileObject)
1042 {
1043     PROS_SHARED_CACHE_MAP SharedCacheMap;
1044     KeAcquireGuardedMutex(&ViewLock);
1045     SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1046     ASSERT(SharedCacheMap);
1047     ASSERT(SharedCacheMap->RefCount != 0);
1048     SharedCacheMap->RefCount++;
1049     KeReleaseGuardedMutex(&ViewLock);
1050 }
1051
1052 VOID
1053 NTAPI
1054 CcRosRemoveIfClosed (
1055     PSECTION_OBJECT_POINTERS SectionObjectPointer)
1056 {
1057     PROS_SHARED_CACHE_MAP SharedCacheMap;
1058     DPRINT("CcRosRemoveIfClosed()\n");
1059     KeAcquireGuardedMutex(&ViewLock);
1060     SharedCacheMap = SectionObjectPointer->SharedCacheMap;
1061     if (SharedCacheMap && SharedCacheMap->RefCount == 0)
1062     {
1063         CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap);
1064     }
1065     KeReleaseGuardedMutex(&ViewLock);
1066 }
1067
1068
1069 VOID
1070 NTAPI
1071 CcRosDereferenceCache (
1072     PFILE_OBJECT FileObject)
1073 {
1074     PROS_SHARED_CACHE_MAP SharedCacheMap;
1075     KeAcquireGuardedMutex(&ViewLock);
1076     SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1077     ASSERT(SharedCacheMap);
1078     if (SharedCacheMap->RefCount > 0)
1079     {
1080         SharedCacheMap->RefCount--;
1081         if (SharedCacheMap->RefCount == 0)
1082         {
1083             MmFreeSectionSegments(SharedCacheMap->FileObject);
1084             CcRosDeleteFileCache(FileObject, SharedCacheMap);
1085         }
1086     }
1087     KeReleaseGuardedMutex(&ViewLock);
1088 }
1089
1090 NTSTATUS
1091 NTAPI
1092 CcRosReleaseFileCache (
1093     PFILE_OBJECT FileObject)
1094 /*
1095  * FUNCTION: Called by the file system when a handle to a file object
1096  * has been closed.
1097  */
1098 {
1099     PROS_SHARED_CACHE_MAP SharedCacheMap;
1100
1101     KeAcquireGuardedMutex(&ViewLock);
1102
1103     if (FileObject->SectionObjectPointer->SharedCacheMap != NULL)
1104     {
1105         SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1106         if (FileObject->PrivateCacheMap != NULL)
1107         {
1108             FileObject->PrivateCacheMap = NULL;
1109             if (SharedCacheMap->RefCount > 0)
1110             {
1111                 SharedCacheMap->RefCount--;
1112                 if (SharedCacheMap->RefCount == 0)
1113                 {
1114                     MmFreeSectionSegments(SharedCacheMap->FileObject);
1115                     CcRosDeleteFileCache(FileObject, SharedCacheMap);
1116                 }
1117             }
1118         }
1119     }
1120     KeReleaseGuardedMutex(&ViewLock);
1121     return STATUS_SUCCESS;
1122 }
1123
1124 NTSTATUS
1125 NTAPI
1126 CcTryToInitializeFileCache (
1127     PFILE_OBJECT FileObject)
1128 {
1129     PROS_SHARED_CACHE_MAP SharedCacheMap;
1130     NTSTATUS Status;
1131
1132     KeAcquireGuardedMutex(&ViewLock);
1133
1134     ASSERT(FileObject->SectionObjectPointer);
1135     SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1136     if (SharedCacheMap == NULL)
1137     {
1138         Status = STATUS_UNSUCCESSFUL;
1139     }
1140     else
1141     {
1142         if (FileObject->PrivateCacheMap == NULL)
1143         {
1144             FileObject->PrivateCacheMap = SharedCacheMap;
1145             SharedCacheMap->RefCount++;
1146         }
1147         Status = STATUS_SUCCESS;
1148     }
1149     KeReleaseGuardedMutex(&ViewLock);
1150
1151     return Status;
1152 }
1153
1154
1155 NTSTATUS
1156 NTAPI
1157 CcRosInitializeFileCache (
1158     PFILE_OBJECT FileObject,
1159     PCC_FILE_SIZES FileSizes,
1160     PCACHE_MANAGER_CALLBACKS CallBacks,
1161     PVOID LazyWriterContext)
1162 /*
1163  * FUNCTION: Initializes a shared cache map for a file object
1164  */
1165 {
1166     PROS_SHARED_CACHE_MAP SharedCacheMap;
1167
1168     SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1169     DPRINT("CcRosInitializeFileCache(FileObject 0x%p, SharedCacheMap 0x%p)\n",
1170            FileObject, SharedCacheMap);
1171
1172     KeAcquireGuardedMutex(&ViewLock);
1173     if (SharedCacheMap == NULL)
1174     {
1175         SharedCacheMap = ExAllocateFromNPagedLookasideList(&SharedCacheMapLookasideList);
1176         if (SharedCacheMap == NULL)
1177         {
1178             KeReleaseGuardedMutex(&ViewLock);
1179             return STATUS_INSUFFICIENT_RESOURCES;
1180         }
1181         RtlZeroMemory(SharedCacheMap, sizeof(*SharedCacheMap));
1182         ObReferenceObjectByPointer(FileObject,
1183                                    FILE_ALL_ACCESS,
1184                                    NULL,
1185                                    KernelMode);
1186         SharedCacheMap->FileObject = FileObject;
1187         SharedCacheMap->Callbacks = CallBacks;
1188         SharedCacheMap->LazyWriteContext = LazyWriterContext;
1189         SharedCacheMap->SectionSize = FileSizes->AllocationSize;
1190         SharedCacheMap->FileSize = FileSizes->FileSize;
1191         KeInitializeSpinLock(&SharedCacheMap->CacheMapLock);
1192         InitializeListHead(&SharedCacheMap->CacheMapVacbListHead);
1193         FileObject->SectionObjectPointer->SharedCacheMap = SharedCacheMap;
1194     }
1195     if (FileObject->PrivateCacheMap == NULL)
1196     {
1197         FileObject->PrivateCacheMap = SharedCacheMap;
1198         SharedCacheMap->RefCount++;
1199     }
1200     KeReleaseGuardedMutex(&ViewLock);
1201
1202     return STATUS_SUCCESS;
1203 }
1204
1205 /*
1206  * @implemented
1207  */
1208 PFILE_OBJECT
1209 NTAPI
1210 CcGetFileObjectFromSectionPtrs (
1211     IN PSECTION_OBJECT_POINTERS SectionObjectPointers)
1212 {
1213     PROS_SHARED_CACHE_MAP SharedCacheMap;
1214
1215     CCTRACE(CC_API_DEBUG, "SectionObjectPointers=%p\n", SectionObjectPointers);
1216
1217     if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
1218     {
1219         SharedCacheMap = SectionObjectPointers->SharedCacheMap;
1220         ASSERT(SharedCacheMap);
1221         return SharedCacheMap->FileObject;
1222     }
1223     return NULL;
1224 }
1225
1226 VOID
1227 INIT_FUNCTION
1228 NTAPI
1229 CcInitView (
1230     VOID)
1231 {
1232     DPRINT("CcInitView()\n");
1233
1234     InitializeListHead(&DirtyVacbListHead);
1235     InitializeListHead(&VacbLruListHead);
1236     KeInitializeGuardedMutex(&ViewLock);
1237     ExInitializeNPagedLookasideList(&iBcbLookasideList,
1238                                     NULL,
1239                                     NULL,
1240                                     0,
1241                                     sizeof(INTERNAL_BCB),
1242                                     TAG_BCB,
1243                                     20);
1244     ExInitializeNPagedLookasideList(&SharedCacheMapLookasideList,
1245                                     NULL,
1246                                     NULL,
1247                                     0,
1248                                     sizeof(ROS_SHARED_CACHE_MAP),
1249                                     TAG_SHARED_CACHE_MAP,
1250                                     20);
1251     ExInitializeNPagedLookasideList(&VacbLookasideList,
1252                                     NULL,
1253                                     NULL,
1254                                     0,
1255                                     sizeof(ROS_VACB),
1256                                     TAG_VACB,
1257                                     20);
1258
1259     MmInitializeMemoryConsumer(MC_CACHE, CcRosTrimCache);
1260
1261     CcInitCacheZeroPage();
1262 }
1263
1264 /* EOF */