reactos/ntoskrnl/cc/view.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS kernel
   5  * FILE:            ntoskrnl/cc/view.c
   6  * PURPOSE:         Cache manager
   7  *
   8  * PROGRAMMERS:     David Welch (welch@mcmail.com)
   9  */
  10
  11 /* NOTES **********************************************************************
  12  *
  13  * This is not the NT implementation of a file cache nor anything much like
  14  * it.
  15  *
  16  * The general procedure for a filesystem to implement a read or write
  17  * dispatch routine is as follows
  18  *
  19  * (1) If caching for the FCB hasn't been initiated then so do by calling
  20  * CcInitializeFileCache.
  21  *
  22  * (2) For each 4k region which is being read or written obtain a cache page
  23  * by calling CcRequestCachePage.
  24  *
  25  * (3) If either the page is being read or not completely written, and it is
  26  * not up to date then read its data from the underlying medium. If the read
  27  * fails then call CcReleaseCachePage with VALID as FALSE and return a error.
  28  *
  29  * (4) Copy the data into or out of the page as necessary.
  30  *
  31  * (5) Release the cache page
  32  */
  33 /* INCLUDES ******************************************************************/
  34
  35 #include <ntoskrnl.h>
  36 #define NDEBUG
  37 #include <internal/debug.h>
  38
  39 #if defined (ALLOC_PRAGMA)
  40 #pragma alloc_text(INIT, CcInitView)
  41 #endif
  42
  43 /* GLOBALS *******************************************************************/
  44
  45 /*
  46  * If CACHE_BITMAP is defined, the cache manager uses one large memory region
  47  * within the kernel address space and allocate/deallocate space from this block
  48  * over a bitmap. If CACHE_BITMAP is used, the size of the mdl mapping region
  49  * must be reduced (ntoskrnl\mm\mdl.c, MI_MDLMAPPING_REGION_SIZE).
  50  */
  51 //#define CACHE_BITMAP
  52
  53 static LIST_ENTRY DirtySegmentListHead;
  54 static LIST_ENTRY CacheSegmentListHead;
  55 static LIST_ENTRY CacheSegmentLRUListHead;
  56 static LIST_ENTRY ClosedListHead;
  57 ULONG DirtyPageCount=0;
  58
  59 FAST_MUTEX ViewLock;
  60
  61 #ifdef CACHE_BITMAP
  62 #define CI_CACHESEG_MAPPING_REGION_SIZE (128*1024*1024)
  63
  64 static PVOID CiCacheSegMappingRegionBase = NULL;
  65 static RTL_BITMAP CiCacheSegMappingRegionAllocMap;
  66 static ULONG CiCacheSegMappingRegionHint;
  67 static KSPIN_LOCK CiCacheSegMappingRegionLock;
  68 #endif
  69
  70 NPAGED_LOOKASIDE_LIST iBcbLookasideList;
  71 static NPAGED_LOOKASIDE_LIST BcbLookasideList;
  72 static NPAGED_LOOKASIDE_LIST CacheSegLookasideList;
  73
  74 static ULONG CcTimeStamp;
  75 static KEVENT LazyCloseThreadEvent;
  76 static HANDLE LazyCloseThreadHandle;
  77 static CLIENT_ID LazyCloseThreadId;
  78 static volatile BOOLEAN LazyCloseThreadShouldTerminate;
  79
  80 #if defined(__GNUC__)
  81 /* void * alloca(size_t size); */
  82 #elif defined(_MSC_VER)
  83 void* _alloca(size_t size);
  84 #else
  85 #error Unknown compiler for alloca intrinsic stack allocation "function"
  86 #endif
  87
  88 #if defined(DBG) || defined(KDBG)
  89 static void CcRosCacheSegmentIncRefCount_ ( PCACHE_SEGMENT cs, const char* file, int line )
  90 {
  91         ++cs->ReferenceCount;
  92         if ( cs->Bcb->Trace )
  93         {
  94                 DbgPrint("(%s:%i) CacheSegment %p ++RefCount=%d, Dirty %d, PageOut %d\n",
  95                         file, line, cs, cs->ReferenceCount, cs->Dirty, cs->PageOut );
  96         }
  97 }
  98 static void CcRosCacheSegmentDecRefCount_ ( PCACHE_SEGMENT cs, const char* file, int line )
  99 {
 100         --cs->ReferenceCount;
 101         if ( cs->Bcb->Trace )
 102         {
 103                 DbgPrint("(%s:%i) CacheSegment %p --RefCount=%d, Dirty %d, PageOut %d\n",
 104                         file, line, cs, cs->ReferenceCount, cs->Dirty, cs->PageOut );
 105         }
 106 }
 107 #define CcRosCacheSegmentIncRefCount(cs) CcRosCacheSegmentIncRefCount_(cs,__FILE__,__LINE__)
 108 #define CcRosCacheSegmentDecRefCount(cs) CcRosCacheSegmentDecRefCount_(cs,__FILE__,__LINE__)
 109 #else
 110 #define CcRosCacheSegmentIncRefCount(cs) (++((cs)->ReferenceCount))
 111 #define CcRosCacheSegmentDecRefCount(cs) (--((cs)->ReferenceCount))
 112 #endif
 113
 114 NTSTATUS
 115 CcRosInternalFreeCacheSegment(PCACHE_SEGMENT CacheSeg);
 116
 117 BOOLEAN
 118 FASTCALL
 119 CcTryToAcquireBrokenMutex(PFAST_MUTEX FastMutex)
 120 {
 121     KeEnterCriticalRegion();
 122     if (InterlockedCompareExchange(&FastMutex->Count, 0, 1) == 1)
 123     {
 124         FastMutex->Owner = KeGetCurrentThread();
 125         return(TRUE);
 126     }
 127     else
 128     {
 129         KeLeaveCriticalRegion();
 130         return(FALSE);
 131     }
 132 }
 133
 134 /* FUNCTIONS *****************************************************************/
 135
 136 VOID
 137 STDCALL
 138 CcRosTraceCacheMap (
 139         PBCB Bcb,
 140         BOOLEAN Trace )
 141 {
 142 #if defined(DBG) || defined(KDBG)
 143         KIRQL oldirql;
 144         PLIST_ENTRY current_entry;
 145         PCACHE_SEGMENT current;
 146
 147         if ( !Bcb )
 148                 return;
 149
 150         Bcb->Trace = Trace;
 151
 152         if ( Trace )
 153         {
 154                 DPRINT1("Enabling Tracing for CacheMap 0x%p:\n", Bcb );
 155
 156                 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
 157                 KeAcquireSpinLock(&Bcb->BcbLock, &oldirql);
 158
 159                 current_entry = Bcb->BcbSegmentListHead.Flink;
 160                 while (current_entry != &Bcb->BcbSegmentListHead)
 161                 {
 162                         current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT, BcbSegmentListEntry);
 163                         current_entry = current_entry->Flink;
 164
 165                         DPRINT1("  CacheSegment 0x%p enabled, RefCount %d, Dirty %d, PageOut %d\n",
 166                                 current, current->ReferenceCount, current->Dirty, current->PageOut );
 167                 }
 168                 KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
 169                 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
 170         }
 171         else
 172         {
 173                 DPRINT1("Disabling Tracing for CacheMap 0x%p:\n", Bcb );
 174         }
 175
 176 #else
 177         Bcb = Bcb;
 178         Trace = Trace;
 179 #endif
 180 }
 181
 182 NTSTATUS
 183 NTAPI
 184 CcRosFlushCacheSegment(PCACHE_SEGMENT CacheSegment)
 185 {
 186   NTSTATUS Status;
 187   KIRQL oldIrql;
 188   Status = WriteCacheSegment(CacheSegment);
 189   if (NT_SUCCESS(Status))
 190     {
 191       ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
 192       KeAcquireSpinLock(&CacheSegment->Bcb->BcbLock, &oldIrql);
 193       CacheSegment->Dirty = FALSE;
 194       RemoveEntryList(&CacheSegment->DirtySegmentListEntry);
 195       DirtyPageCount -= CacheSegment->Bcb->CacheSegmentSize / PAGE_SIZE;
 196       CcRosCacheSegmentDecRefCount ( CacheSegment );
 197       KeReleaseSpinLock(&CacheSegment->Bcb->BcbLock, oldIrql);
 198       ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
 199     }
 200   return(Status);
 201 }
 202
 203 NTSTATUS
 204 NTAPI
 205 CcRosFlushDirtyPages(ULONG Target, PULONG Count)
 206 {
 207   PLIST_ENTRY current_entry;
 208   PCACHE_SEGMENT current;
 209   ULONG PagesPerSegment;
 210   BOOLEAN Locked;
 211   NTSTATUS Status;
 212   static ULONG WriteCount[4] = {0, 0, 0, 0};
 213   ULONG NewTarget;
 214
 215   DPRINT("CcRosFlushDirtyPages(Target %d)\n", Target);
 216
 217   (*Count) = 0;
 218
 219   ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
 220
 221   WriteCount[0] = WriteCount[1];
 222   WriteCount[1] = WriteCount[2];
 223   WriteCount[2] = WriteCount[3];
 224   WriteCount[3] = 0;
 225
 226   NewTarget = WriteCount[0] + WriteCount[1] + WriteCount[2];
 227
 228   if (NewTarget < DirtyPageCount)
 229   {
 230      NewTarget = (DirtyPageCount - NewTarget + 3) / 4;
 231      WriteCount[0] += NewTarget;
 232      WriteCount[1] += NewTarget;
 233      WriteCount[2] += NewTarget;
 234      WriteCount[3] += NewTarget;
 235   }
 236
 237   NewTarget = WriteCount[0];
 238
 239   Target = max(NewTarget, Target);
 240
 241   current_entry = DirtySegmentListHead.Flink;
 242   if (current_entry == &DirtySegmentListHead)
 243   {
 244      DPRINT("No Dirty pages\n");
 245   }
 246   while (current_entry != &DirtySegmentListHead && Target > 0)
 247     {
 248       current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
 249                                   DirtySegmentListEntry);
 250       current_entry = current_entry->Flink;
 251
 252 //      Locked = current->Bcb->Callbacks.AcquireForLazyWrite(current->Bcb->Context, FALSE);
 253       Locked = ExTryToAcquireResourceExclusiveLite(((FSRTL_COMMON_FCB_HEADER*)(current->Bcb->FileObject->FsContext))->Resource);
 254       if (!Locked)
 255         {
 256           continue;
 257         }
 258       Locked = CcTryToAcquireBrokenMutex(&current->Lock);
 259       if (!Locked)
 260         {
 261 //          current->Bcb->Callbacks.ReleaseFromLazyWrite(current->Bcb->Context);
 262           ExReleaseResourceLite(((FSRTL_COMMON_FCB_HEADER*)(current->Bcb->FileObject->FsContext))->Resource);
 263           continue;
 264         }
 265       ASSERT(current->Dirty);
 266       if (current->ReferenceCount > 1)
 267         {
 268           ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&current->Lock);
 269 //          current->Bcb->Callbacks.ReleaseFromLazyWrite(current->Bcb->Context);
 270           ExReleaseResourceLite(((FSRTL_COMMON_FCB_HEADER*)(current->Bcb->FileObject->FsContext))->Resource);
 271           continue;
 272         }
 273       ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
 274       PagesPerSegment = current->Bcb->CacheSegmentSize / PAGE_SIZE;
 275       Status = CcRosFlushCacheSegment(current);
 276       ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&current->Lock);
 277 //      current->Bcb->Callbacks.ReleaseFromLazyWrite(current->Bcb->Context);
 278       ExReleaseResourceLite(((FSRTL_COMMON_FCB_HEADER*)(current->Bcb->FileObject->FsContext))->Resource);
 279       if (!NT_SUCCESS(Status) &&  (Status != STATUS_END_OF_FILE))
 280       {
 281          DPRINT1("CC: Failed to flush cache segment.\n");
 282       }
 283       else
 284       {
 285          (*Count) += PagesPerSegment;
 286          Target -= PagesPerSegment;
 287       }
 288       ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
 289       current_entry = DirtySegmentListHead.Flink;
 290     }
 291   if (*Count < NewTarget)
 292   {
 293      WriteCount[1] += (NewTarget - *Count);
 294   }
 295   ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
 296   DPRINT("CcRosFlushDirtyPages() finished\n");
 297
 298   return(STATUS_SUCCESS);
 299 }
 300
 301 NTSTATUS
 302 CcRosTrimCache(ULONG Target, ULONG Priority, PULONG NrFreed)
 303 /*
 304  * FUNCTION: Try to free some memory from the file cache.
 305  * ARGUMENTS:
 306  *       Target - The number of pages to be freed.
 307  *       Priority - The priority of free (currently unused).
 308  *       NrFreed - Points to a variable where the number of pages
 309  *                 actually freed is returned.
 310  */
 311 {
 312   PLIST_ENTRY current_entry;
 313   PCACHE_SEGMENT current, last = NULL;
 314   ULONG PagesPerSegment;
 315   ULONG PagesFreed;
 316   KIRQL oldIrql;
 317   LIST_ENTRY FreeList;
 318
 319   DPRINT("CcRosTrimCache(Target %d)\n", Target);
 320
 321   *NrFreed = 0;
 322
 323   InitializeListHead(&FreeList);
 324
 325   ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
 326   current_entry = CacheSegmentLRUListHead.Flink;
 327   while (current_entry != &CacheSegmentLRUListHead && Target > 0)
 328     {
 329       current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
 330                                   CacheSegmentLRUListEntry);
 331       current_entry = current_entry->Flink;
 332
 333       KeAcquireSpinLock(&current->Bcb->BcbLock, &oldIrql);
 334       if (current->ReferenceCount == 0)
 335       {
 336          RemoveEntryList(&current->BcbSegmentListEntry);
 337          KeReleaseSpinLock(&current->Bcb->BcbLock, oldIrql);
 338          RemoveEntryList(&current->CacheSegmentListEntry);
 339          RemoveEntryList(&current->CacheSegmentLRUListEntry);
 340          InsertHeadList(&FreeList, &current->BcbSegmentListEntry);
 341          PagesPerSegment = current->Bcb->CacheSegmentSize / PAGE_SIZE;
 342          PagesFreed = min(PagesPerSegment, Target);
 343          Target -= PagesFreed;
 344          (*NrFreed) += PagesFreed;
 345       }
 346       else
 347       {
 348          if (last != current && current->MappedCount > 0 && !current->Dirty && !current->PageOut)
 349            {
 350              ULONG i;
 351              NTSTATUS Status;
 352
 353          CcRosCacheSegmentIncRefCount(current);
 354              last = current;
 355              current->PageOut = TRUE;
 356              KeReleaseSpinLock(&current->Bcb->BcbLock, oldIrql);
 357              ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
 358              for (i = 0; i < current->Bcb->CacheSegmentSize / PAGE_SIZE; i++)
 359                {
 360                  PFN_TYPE Page;
 361                  Page = MmGetPhysicalAddress((char*)current->BaseAddress + i * PAGE_SIZE).QuadPart >> PAGE_SHIFT;
 362                  Status = MmPageOutPhysicalAddress(Page);
 363                  if (!NT_SUCCESS(Status))
 364                    {
 365                      break;
 366                    }
 367                }
 368              ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
 369              KeAcquireSpinLock(&current->Bcb->BcbLock, &oldIrql);
 370              CcRosCacheSegmentDecRefCount(current);
 371              current->PageOut = FALSE;
 372              KeReleaseSpinLock(&current->Bcb->BcbLock, oldIrql);
 373              current_entry = &current->CacheSegmentLRUListEntry;
 374              continue;
 375            }
 376          KeReleaseSpinLock(&current->Bcb->BcbLock, oldIrql);
 377       }
 378   }
 379   ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
 380
 381   while (!IsListEmpty(&FreeList))
 382   {
 383      current_entry = RemoveHeadList(&FreeList);
 384      current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
 385                                  BcbSegmentListEntry);
 386      CcRosInternalFreeCacheSegment(current);
 387   }
 388
 389   DPRINT("CcRosTrimCache() finished\n");
 390   return(STATUS_SUCCESS);
 391 }
 392
 393 NTSTATUS
 394 NTAPI
 395 CcRosReleaseCacheSegment(PBCB Bcb,
 396                          PCACHE_SEGMENT CacheSeg,
 397                          BOOLEAN Valid,
 398                          BOOLEAN Dirty,
 399                          BOOLEAN Mapped)
 400 {
 401   BOOLEAN WasDirty = CacheSeg->Dirty;
 402   KIRQL oldIrql;
 403
 404   ASSERT(Bcb);
 405
 406   DPRINT("CcReleaseCacheSegment(Bcb 0x%p, CacheSeg 0x%p, Valid %d)\n",
 407          Bcb, CacheSeg, Valid);
 408
 409   CacheSeg->Valid = Valid;
 410   CacheSeg->Dirty = CacheSeg->Dirty || Dirty;
 411
 412   ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
 413   if (!WasDirty && CacheSeg->Dirty)
 414     {
 415       InsertTailList(&DirtySegmentListHead, &CacheSeg->DirtySegmentListEntry);
 416       DirtyPageCount += Bcb->CacheSegmentSize / PAGE_SIZE;
 417     }
 418   RemoveEntryList(&CacheSeg->CacheSegmentLRUListEntry);
 419   InsertTailList(&CacheSegmentLRUListHead, &CacheSeg->CacheSegmentLRUListEntry);
 420
 421   if (Mapped)
 422   {
 423      CacheSeg->MappedCount++;
 424   }
 425   KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
 426   CcRosCacheSegmentDecRefCount(CacheSeg);
 427   if (Mapped && CacheSeg->MappedCount == 1)
 428   {
 429       CcRosCacheSegmentIncRefCount(CacheSeg);
 430   }
 431   if (!WasDirty && CacheSeg->Dirty)
 432   {
 433       CcRosCacheSegmentIncRefCount(CacheSeg);
 434   }
 435   KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
 436   ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
 437   ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&CacheSeg->Lock);
 438
 439   return(STATUS_SUCCESS);
 440 }
 441
 442 PCACHE_SEGMENT
 443 NTAPI
 444 CcRosLookupCacheSegment(PBCB Bcb, ULONG FileOffset)
 445 {
 446   PLIST_ENTRY current_entry;
 447   PCACHE_SEGMENT current;
 448   KIRQL oldIrql;
 449
 450   ASSERT(Bcb);
 451
 452   DPRINT("CcRosLookupCacheSegment(Bcb -x%p, FileOffset %d)\n", Bcb, FileOffset);
 453
 454   KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
 455   current_entry = Bcb->BcbSegmentListHead.Flink;
 456   while (current_entry != &Bcb->BcbSegmentListHead)
 457     {
 458       current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
 459                                   BcbSegmentListEntry);
 460       if (current->FileOffset <= FileOffset &&
 461           (current->FileOffset + Bcb->CacheSegmentSize) > FileOffset)
 462         {
 463           CcRosCacheSegmentIncRefCount(current);
 464           KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
 465           ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&current->Lock);
 466           return(current);
 467         }
 468       current_entry = current_entry->Flink;
 469     }
 470   KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
 471   return(NULL);
 472 }
 473
 474 NTSTATUS
 475 NTAPI
 476 CcRosMarkDirtyCacheSegment(PBCB Bcb, ULONG FileOffset)
 477 {
 478   PCACHE_SEGMENT CacheSeg;
 479   KIRQL oldIrql;
 480
 481   ASSERT(Bcb);
 482
 483   DPRINT("CcRosMarkDirtyCacheSegment(Bcb 0x%p, FileOffset %d)\n", Bcb, FileOffset);
 484
 485   CacheSeg = CcRosLookupCacheSegment(Bcb, FileOffset);
 486   if (CacheSeg == NULL)
 487     {
 488       KEBUGCHECKCC;
 489     }
 490   if (!CacheSeg->Dirty)
 491     {
 492       ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
 493       InsertTailList(&DirtySegmentListHead, &CacheSeg->DirtySegmentListEntry);
 494       DirtyPageCount += Bcb->CacheSegmentSize / PAGE_SIZE;
 495       ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
 496     }
 497   else
 498   {
 499      KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
 500      CcRosCacheSegmentDecRefCount(CacheSeg);
 501      KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
 502   }
 503
 504
 505   CacheSeg->Dirty = TRUE;
 506   ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&CacheSeg->Lock);
 507
 508   return(STATUS_SUCCESS);
 509 }
 510
 511 NTSTATUS
 512 NTAPI
 513 CcRosUnmapCacheSegment(PBCB Bcb, ULONG FileOffset, BOOLEAN NowDirty)
 514 {
 515   PCACHE_SEGMENT CacheSeg;
 516   BOOLEAN WasDirty;
 517   KIRQL oldIrql;
 518
 519   ASSERT(Bcb);
 520
 521   DPRINT("CcRosUnmapCacheSegment(Bcb 0x%p, FileOffset %d, NowDirty %d)\n",
 522           Bcb, FileOffset, NowDirty);
 523
 524   CacheSeg = CcRosLookupCacheSegment(Bcb, FileOffset);
 525   if (CacheSeg == NULL)
 526     {
 527       return(STATUS_UNSUCCESSFUL);
 528     }
 529
 530   WasDirty = CacheSeg->Dirty;
 531   CacheSeg->Dirty = CacheSeg->Dirty || NowDirty;
 532
 533   CacheSeg->MappedCount--;
 534
 535   if (!WasDirty && NowDirty)
 536   {
 537      ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
 538      InsertTailList(&DirtySegmentListHead, &CacheSeg->DirtySegmentListEntry);
 539      DirtyPageCount += Bcb->CacheSegmentSize / PAGE_SIZE;
 540      ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
 541   }
 542
 543   KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
 544   CcRosCacheSegmentDecRefCount(CacheSeg);
 545   if (!WasDirty && NowDirty)
 546   {
 547      CcRosCacheSegmentIncRefCount(CacheSeg);
 548   }
 549   if (CacheSeg->MappedCount == 0)
 550   {
 551      CcRosCacheSegmentDecRefCount(CacheSeg);
 552   }
 553   KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
 554
 555   ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&CacheSeg->Lock);
 556   return(STATUS_SUCCESS);
 557 }
 558
 559 NTSTATUS STATIC
 560 CcRosCreateCacheSegment(PBCB Bcb,
 561                         ULONG FileOffset,
 562                         PCACHE_SEGMENT* CacheSeg)
 563 {
 564   ULONG i;
 565   PCACHE_SEGMENT current;
 566   PCACHE_SEGMENT previous;
 567   PLIST_ENTRY current_entry;
 568   NTSTATUS Status;
 569   KIRQL oldIrql;
 570   PPFN_TYPE Pfn;
 571 #ifdef CACHE_BITMAP
 572   ULONG StartingOffset;
 573 #else
 574 #endif
 575   PHYSICAL_ADDRESS BoundaryAddressMultiple;
 576
 577   ASSERT(Bcb);
 578
 579   DPRINT("CcRosCreateCacheSegment()\n");
 580
 581   BoundaryAddressMultiple.QuadPart = 0;
 582   if (FileOffset >= Bcb->FileSize.u.LowPart)
 583   {
 584      CacheSeg = NULL;
 585      return STATUS_INVALID_PARAMETER;
 586   }
 587
 588   current = ExAllocateFromNPagedLookasideList(&CacheSegLookasideList);
 589   current->Valid = FALSE;
 590   current->Dirty = FALSE;
 591   current->PageOut = FALSE;
 592   current->FileOffset = ROUND_DOWN(FileOffset, Bcb->CacheSegmentSize);
 593   current->Bcb = Bcb;
 594 #if defined(DBG) || defined(KDBG)
 595   if ( Bcb->Trace )
 596   {
 597     DPRINT1("CacheMap 0x%p: new Cache Segment: 0x%p\n", Bcb, current );
 598   }
 599 #endif
 600   current->MappedCount = 0;
 601   current->DirtySegmentListEntry.Flink = NULL;
 602   current->DirtySegmentListEntry.Blink = NULL;
 603   current->ReferenceCount = 1;
 604   ExInitializeFastMutex(&current->Lock);
 605   ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&current->Lock);
 606   ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
 607
 608   *CacheSeg = current;
 609   /* There is window between the call to CcRosLookupCacheSegment
 610    * and CcRosCreateCacheSegment. We must check if a segment on
 611    * the fileoffset exist. If there exist a segment, we release
 612    * our new created segment and return the existing one.
 613    */
 614   KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
 615   current_entry = Bcb->BcbSegmentListHead.Flink;
 616   previous = NULL;
 617   while (current_entry != &Bcb->BcbSegmentListHead)
 618   {
 619      current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
 620                                  BcbSegmentListEntry);
 621      if (current->FileOffset <= FileOffset &&
 622         (current->FileOffset + Bcb->CacheSegmentSize) > FileOffset)
 623      {
 624         CcRosCacheSegmentIncRefCount(current);
 625         KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
 626 #if defined(DBG) || defined(KDBG)
 627         if ( Bcb->Trace )
 628         {
 629                 DPRINT1("CacheMap 0x%p: deleting newly created Cache Segment 0x%p ( found existing one 0x%p )\n",
 630                         Bcb,
 631                         (*CacheSeg),
 632                         current );
 633         }
 634 #endif
 635         ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&(*CacheSeg)->Lock);
 636         ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
 637         ExFreeToNPagedLookasideList(&CacheSegLookasideList, *CacheSeg);
 638         *CacheSeg = current;
 639         ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&current->Lock);
 640         return STATUS_SUCCESS;
 641      }
 642      if (current->FileOffset < FileOffset)
 643      {
 644         if (previous == NULL)
 645         {
 646            previous = current;
 647         }
 648         else
 649         {
 650            if (previous->FileOffset < current->FileOffset)
 651            {
 652               previous = current;
 653            }
 654         }
 655      }
 656      current_entry = current_entry->Flink;
 657   }
 658   /* There was no existing segment. */
 659   current = *CacheSeg;
 660   if (previous)
 661   {
 662      InsertHeadList(&previous->BcbSegmentListEntry, &current->BcbSegmentListEntry);
 663   }
 664   else
 665   {
 666      InsertHeadList(&Bcb->BcbSegmentListHead, &current->BcbSegmentListEntry);
 667   }
 668   KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
 669   InsertTailList(&CacheSegmentListHead, &current->CacheSegmentListEntry);
 670   InsertTailList(&CacheSegmentLRUListHead, &current->CacheSegmentLRUListEntry);
 671   ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
 672 #ifdef CACHE_BITMAP
 673   KeAcquireSpinLock(&CiCacheSegMappingRegionLock, &oldIrql);
 674
 675   StartingOffset = RtlFindClearBitsAndSet(&CiCacheSegMappingRegionAllocMap, Bcb->CacheSegmentSize / PAGE_SIZE, CiCacheSegMappingRegionHint);
 676
 677   if (StartingOffset == 0xffffffff)
 678   {
 679      DPRINT1("Out of CacheSeg mapping space\n");
 680      KEBUGCHECKCC;
 681   }
 682
 683   current->BaseAddress = CiCacheSegMappingRegionBase + StartingOffset * PAGE_SIZE;
 684
 685   if (CiCacheSegMappingRegionHint == StartingOffset)
 686   {
 687      CiCacheSegMappingRegionHint += Bcb->CacheSegmentSize / PAGE_SIZE;
 688   }
 689
 690   KeReleaseSpinLock(&CiCacheSegMappingRegionLock, oldIrql);
 691 #else
 692   MmLockAddressSpace(MmGetKernelAddressSpace());
 693   current->BaseAddress = NULL;
 694   Status = MmCreateMemoryArea(MmGetKernelAddressSpace(),
 695                               MEMORY_AREA_CACHE_SEGMENT,
 696                               &current->BaseAddress,
 697                               Bcb->CacheSegmentSize,
 698                               PAGE_READWRITE,
 699                               (PMEMORY_AREA*)&current->MemoryArea,
 700                               FALSE,
 701                               0,
 702                               BoundaryAddressMultiple);
 703   MmUnlockAddressSpace(MmGetKernelAddressSpace());
 704   if (!NT_SUCCESS(Status))
 705   {
 706      KEBUGCHECKCC;
 707   }
 708 #endif
 709   Pfn = alloca(sizeof(PFN_TYPE) * (Bcb->CacheSegmentSize / PAGE_SIZE));
 710   for (i = 0; i < (Bcb->CacheSegmentSize / PAGE_SIZE); i++)
 711   {
 712      Status = MmRequestPageMemoryConsumer(MC_CACHE, TRUE, &Pfn[i]);
 713      if (!NT_SUCCESS(Status))
 714      {
 715         KEBUGCHECKCC;
 716      }
 717   }
 718   Status = MmCreateVirtualMapping(NULL,
 719                                   current->BaseAddress,
 720                                   PAGE_READWRITE,
 721                                   Pfn,
 722                                   Bcb->CacheSegmentSize / PAGE_SIZE);
 723   if (!NT_SUCCESS(Status))
 724   {
 725     KEBUGCHECKCC;
 726   }
 727   return(STATUS_SUCCESS);
 728 }
 729
 730 NTSTATUS
 731 NTAPI
 732 CcRosGetCacheSegmentChain(PBCB Bcb,
 733                           ULONG FileOffset,
 734                           ULONG Length,
 735                           PCACHE_SEGMENT* CacheSeg)
 736 {
 737   PCACHE_SEGMENT current;
 738   ULONG i;
 739   PCACHE_SEGMENT* CacheSegList;
 740   PCACHE_SEGMENT Previous = NULL;
 741
 742   ASSERT(Bcb);
 743
 744   DPRINT("CcRosGetCacheSegmentChain()\n");
 745
 746   Length = ROUND_UP(Length, Bcb->CacheSegmentSize);
 747
 748 #if defined(__GNUC__)
 749   CacheSegList = alloca(sizeof(PCACHE_SEGMENT) *
 750                         (Length / Bcb->CacheSegmentSize));
 751 #elif defined(_MSC_VER)
 752   CacheSegList = _alloca(sizeof(PCACHE_SEGMENT) *
 753                         (Length / Bcb->CacheSegmentSize));
 754 #else
 755 #error Unknown compiler for alloca intrinsic stack allocation "function"
 756 #endif
 757
 758   /*
 759    * Look for a cache segment already mapping the same data.
 760    */
 761   for (i = 0; i < (Length / Bcb->CacheSegmentSize); i++)
 762     {
 763       ULONG CurrentOffset = FileOffset + (i * Bcb->CacheSegmentSize);
 764       current = CcRosLookupCacheSegment(Bcb, CurrentOffset);
 765       if (current != NULL)
 766         {
 767           CacheSegList[i] = current;
 768         }
 769       else
 770         {
 771           CcRosCreateCacheSegment(Bcb, CurrentOffset, &current);
 772           CacheSegList[i] = current;
 773         }
 774     }
 775
 776   for (i = 0; i < (Length / Bcb->CacheSegmentSize); i++)
 777     {
 778       if (i == 0)
 779         {
 780           *CacheSeg = CacheSegList[i];
 781           Previous = CacheSegList[i];
 782         }
 783       else
 784         {
 785           Previous->NextInChain = CacheSegList[i];
 786           Previous = CacheSegList[i];
 787         }
 788     }
 789   Previous->NextInChain = NULL;
 790
 791   return(STATUS_SUCCESS);
 792 }
 793
 794 NTSTATUS
 795 NTAPI
 796 CcRosGetCacheSegment(PBCB Bcb,
 797                      ULONG FileOffset,
 798                      PULONG BaseOffset,
 799                      PVOID* BaseAddress,
 800                      PBOOLEAN UptoDate,
 801                      PCACHE_SEGMENT* CacheSeg)
 802 {
 803    PCACHE_SEGMENT current;
 804    NTSTATUS Status;
 805
 806    ASSERT(Bcb);
 807
 808    DPRINT("CcRosGetCacheSegment()\n");
 809
 810    /*
 811     * Look for a cache segment already mapping the same data.
 812     */
 813    current = CcRosLookupCacheSegment(Bcb, FileOffset);
 814    if (current == NULL)
 815    {
 816      /*
 817       * Otherwise create a new segment.
 818       */
 819       Status = CcRosCreateCacheSegment(Bcb, FileOffset, &current);
 820       if (!NT_SUCCESS(Status))
 821       {
 822         return Status;
 823       }
 824    }
 825    /*
 826     * Return information about the segment to the caller.
 827     */
 828    *UptoDate = current->Valid;
 829    *BaseAddress = current->BaseAddress;
 830    DPRINT("*BaseAddress 0x%.8X\n", *BaseAddress);
 831    *CacheSeg = current;
 832    *BaseOffset = current->FileOffset;
 833    return(STATUS_SUCCESS);
 834 }
 835
 836 NTSTATUS STDCALL
 837 CcRosRequestCacheSegment(PBCB Bcb,
 838                       ULONG FileOffset,
 839                       PVOID* BaseAddress,
 840                       PBOOLEAN UptoDate,
 841                       PCACHE_SEGMENT* CacheSeg)
 842 /*
 843  * FUNCTION: Request a page mapping for a BCB
 844  */
 845 {
 846   ULONG BaseOffset;
 847
 848   ASSERT(Bcb);
 849
 850   if ((FileOffset % Bcb->CacheSegmentSize) != 0)
 851     {
 852       CPRINT("Bad fileoffset %x should be multiple of %x",
 853         FileOffset, Bcb->CacheSegmentSize);
 854       KEBUGCHECKCC;
 855     }
 856
 857   return(CcRosGetCacheSegment(Bcb,
 858                            FileOffset,
 859                            &BaseOffset,
 860                            BaseAddress,
 861                            UptoDate,
 862                            CacheSeg));
 863 }
 864 #ifdef CACHE_BITMAP
 865 #else
 866 STATIC VOID
 867 CcFreeCachePage(PVOID Context, MEMORY_AREA* MemoryArea, PVOID Address,
 868                 PFN_TYPE Page, SWAPENTRY SwapEntry, BOOLEAN Dirty)
 869 {
 870   ASSERT(SwapEntry == 0);
 871   if (Page != 0)
 872     {
 873       MmReleasePageMemoryConsumer(MC_CACHE, Page);
 874     }
 875 }
 876 #endif
 877 NTSTATUS
 878 CcRosInternalFreeCacheSegment(PCACHE_SEGMENT CacheSeg)
 879 /*
 880  * FUNCTION: Releases a cache segment associated with a BCB
 881  */
 882 {
 883 #ifdef CACHE_BITMAP
 884   ULONG i;
 885   ULONG RegionSize;
 886   ULONG Base;
 887   PFN_TYPE Page;
 888   KIRQL oldIrql;
 889 #endif
 890   DPRINT("Freeing cache segment 0x%p\n", CacheSeg);
 891 #if defined(DBG) || defined(KDBG)
 892         if ( CacheSeg->Bcb->Trace )
 893         {
 894                 DPRINT1("CacheMap 0x%p: deleting Cache Segment: 0x%p\n", CacheSeg->Bcb, CacheSeg );
 895         }
 896 #endif
 897 #ifdef CACHE_BITMAP
 898   RegionSize = CacheSeg->Bcb->CacheSegmentSize / PAGE_SIZE;
 899
 900   /* Unmap all the pages. */
 901   for (i = 0; i < RegionSize; i++)
 902     {
 903       MmDeleteVirtualMapping(NULL,
 904                              CacheSeg->BaseAddress + (i * PAGE_SIZE),
 905                              FALSE,
 906                              NULL,
 907                              &Page);
 908       MmReleasePageMemoryConsumer(MC_CACHE, Page);
 909     }
 910
 911   KeAcquireSpinLock(&CiCacheSegMappingRegionLock, &oldIrql);
 912   /* Deallocate all the pages used. */
 913   Base = (ULONG)(CacheSeg->BaseAddress - CiCacheSegMappingRegionBase) / PAGE_SIZE;
 914
 915   RtlClearBits(&CiCacheSegMappingRegionAllocMap, Base, RegionSize);
 916
 917   CiCacheSegMappingRegionHint = min (CiCacheSegMappingRegionHint, Base);
 918
 919   KeReleaseSpinLock(&CiCacheSegMappingRegionLock, oldIrql);
 920 #else
 921   MmLockAddressSpace(MmGetKernelAddressSpace());
 922   MmFreeMemoryArea(MmGetKernelAddressSpace(),
 923                    CacheSeg->MemoryArea,
 924                    CcFreeCachePage,
 925                    NULL);
 926   MmUnlockAddressSpace(MmGetKernelAddressSpace());
 927 #endif
 928   ExFreeToNPagedLookasideList(&CacheSegLookasideList, CacheSeg);
 929   return(STATUS_SUCCESS);
 930 }
 931
 932 NTSTATUS
 933 NTAPI
 934 CcRosFreeCacheSegment(PBCB Bcb, PCACHE_SEGMENT CacheSeg)
 935 {
 936   NTSTATUS Status;
 937   KIRQL oldIrql;
 938
 939   ASSERT(Bcb);
 940
 941   DPRINT("CcRosFreeCacheSegment(Bcb 0x%p, CacheSeg 0x%p)\n",
 942          Bcb, CacheSeg);
 943
 944   ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
 945   KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
 946   RemoveEntryList(&CacheSeg->BcbSegmentListEntry);
 947   RemoveEntryList(&CacheSeg->CacheSegmentListEntry);
 948   RemoveEntryList(&CacheSeg->CacheSegmentLRUListEntry);
 949   if (CacheSeg->Dirty)
 950   {
 951      RemoveEntryList(&CacheSeg->DirtySegmentListEntry);
 952      DirtyPageCount -= Bcb->CacheSegmentSize / PAGE_SIZE;
 953
 954   }
 955   KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
 956   ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
 957
 958   Status = CcRosInternalFreeCacheSegment(CacheSeg);
 959   return(Status);
 960 }
 961
 962 /*
 963  * @implemented
 964  */
 965 VOID STDCALL
 966 CcFlushCache(IN PSECTION_OBJECT_POINTERS SectionObjectPointers,
 967              IN PLARGE_INTEGER FileOffset OPTIONAL,
 968              IN ULONG Length,
 969              OUT PIO_STATUS_BLOCK IoStatus)
 970 {
 971    PBCB Bcb;
 972    LARGE_INTEGER Offset;
 973    PCACHE_SEGMENT current;
 974    NTSTATUS Status;
 975    KIRQL oldIrql;
 976
 977    DPRINT("CcFlushCache(SectionObjectPointers 0x%p, FileOffset 0x%p, Length %d, IoStatus 0x%p)\n",
 978            SectionObjectPointers, FileOffset, Length, IoStatus);
 979
 980    if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
 981    {
 982       Bcb = (PBCB)SectionObjectPointers->SharedCacheMap;
 983       ASSERT(Bcb);
 984       if (FileOffset)
 985       {
 986          Offset = *FileOffset;
 987       }
 988       else
 989       {
 990          Offset.QuadPart = (LONGLONG)0;
 991          Length = Bcb->FileSize.u.LowPart;
 992       }
 993
 994       if (IoStatus)
 995       {
 996          IoStatus->Status = STATUS_SUCCESS;
 997          IoStatus->Information = 0;
 998       }
 999
1000       while (Length > 0)
1001       {
1002          current = CcRosLookupCacheSegment (Bcb, Offset.u.LowPart);
1003          if (current != NULL)
1004          {
1005             if (current->Dirty)
1006             {
1007                Status = CcRosFlushCacheSegment(current);
1008                if (!NT_SUCCESS(Status) && IoStatus != NULL)
1009                {
1010                    IoStatus->Status = Status;
1011                }
1012             }
1013             KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
1014             ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&current->Lock);
1015             CcRosCacheSegmentDecRefCount(current);
1016             KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
1017          }
1018
1019          Offset.QuadPart += Bcb->CacheSegmentSize;
1020          if (Length > Bcb->CacheSegmentSize)
1021          {
1022             Length -= Bcb->CacheSegmentSize;
1023          }
1024          else
1025          {
1026             Length = 0;
1027          }
1028       }
1029    }
1030    else
1031    {
1032       if (IoStatus)
1033       {
1034          IoStatus->Status = STATUS_INVALID_PARAMETER;
1035       }
1036    }
1037 }
1038
1039 NTSTATUS
1040 NTAPI
1041 CcRosDeleteFileCache(PFILE_OBJECT FileObject, PBCB Bcb)
1042 /*
1043  * FUNCTION: Releases the BCB associated with a file object
1044  */
1045 {
1046    PLIST_ENTRY current_entry;
1047    PCACHE_SEGMENT current;
1048    NTSTATUS Status;
1049    LIST_ENTRY FreeList;
1050    KIRQL oldIrql;
1051
1052    ASSERT(Bcb);
1053
1054    Bcb->RefCount++;
1055    ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
1056
1057    CcFlushCache(FileObject->SectionObjectPointer, NULL, 0, NULL);
1058
1059    ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
1060    Bcb->RefCount--;
1061    if (Bcb->RefCount == 0)
1062    {
1063       if (Bcb->BcbRemoveListEntry.Flink != NULL)
1064       {
1065          RemoveEntryList(&Bcb->BcbRemoveListEntry);
1066          Bcb->BcbRemoveListEntry.Flink = NULL;
1067       }
1068
1069       FileObject->SectionObjectPointer->SharedCacheMap = NULL;
1070
1071       /*
1072        * Release all cache segments.
1073        */
1074       InitializeListHead(&FreeList);
1075       KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
1076       current_entry = Bcb->BcbSegmentListHead.Flink;
1077       while (!IsListEmpty(&Bcb->BcbSegmentListHead))
1078       {
1079          current_entry = RemoveTailList(&Bcb->BcbSegmentListHead);
1080          current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT, BcbSegmentListEntry);
1081          RemoveEntryList(&current->CacheSegmentListEntry);
1082          RemoveEntryList(&current->CacheSegmentLRUListEntry);
1083          if (current->Dirty)
1084          {
1085             RemoveEntryList(&current->DirtySegmentListEntry);
1086             DirtyPageCount -= Bcb->CacheSegmentSize / PAGE_SIZE;
1087             DPRINT1("Freeing dirty segment\n");
1088          }
1089          InsertHeadList(&FreeList, &current->BcbSegmentListEntry);
1090       }
1091 #if defined(DBG) || defined(KDBG)
1092       Bcb->Trace = FALSE;
1093 #endif
1094       KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
1095
1096       ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
1097       ObDereferenceObject (Bcb->FileObject);
1098
1099       while (!IsListEmpty(&FreeList))
1100       {
1101          current_entry = RemoveTailList(&FreeList);
1102          current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT, BcbSegmentListEntry);
1103          Status = CcRosInternalFreeCacheSegment(current);
1104       }
1105       ExFreeToNPagedLookasideList(&BcbLookasideList, Bcb);
1106       ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
1107    }
1108    return(STATUS_SUCCESS);
1109 }
1110
1111 VOID
1112 NTAPI
1113 CcRosReferenceCache(PFILE_OBJECT FileObject)
1114 {
1115   PBCB Bcb;
1116   ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
1117   Bcb = (PBCB)FileObject->SectionObjectPointer->SharedCacheMap;
1118   ASSERT(Bcb);
1119   if (Bcb->RefCount == 0)
1120   {
1121      ASSERT(Bcb->BcbRemoveListEntry.Flink != NULL);
1122      RemoveEntryList(&Bcb->BcbRemoveListEntry);
1123      Bcb->BcbRemoveListEntry.Flink = NULL;
1124
1125   }
1126   else
1127   {
1128      ASSERT(Bcb->BcbRemoveListEntry.Flink == NULL);
1129   }
1130   Bcb->RefCount++;
1131   ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
1132 }
1133
1134 VOID
1135 NTAPI
1136 CcRosSetRemoveOnClose(PSECTION_OBJECT_POINTERS SectionObjectPointer)
1137 {
1138   PBCB Bcb;
1139   DPRINT("CcRosSetRemoveOnClose()\n");
1140   ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
1141   Bcb = (PBCB)SectionObjectPointer->SharedCacheMap;
1142   if (Bcb)
1143   {
1144     Bcb->RemoveOnClose = TRUE;
1145     if (Bcb->RefCount == 0)
1146     {
1147       CcRosDeleteFileCache(Bcb->FileObject, Bcb);
1148     }
1149   }
1150   ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
1151 }
1152
1153
1154 VOID
1155 NTAPI
1156 CcRosDereferenceCache(PFILE_OBJECT FileObject)
1157 {
1158   PBCB Bcb;
1159   ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
1160   Bcb = (PBCB)FileObject->SectionObjectPointer->SharedCacheMap;
1161   ASSERT(Bcb);
1162   if (Bcb->RefCount > 0)
1163   {
1164     Bcb->RefCount--;
1165     if (Bcb->RefCount == 0)
1166     {
1167        MmFreeSectionSegments(Bcb->FileObject);
1168        if (Bcb->RemoveOnClose)
1169        {
1170           CcRosDeleteFileCache(FileObject, Bcb);
1171        }
1172        else
1173        {
1174           Bcb->TimeStamp = CcTimeStamp;
1175           InsertHeadList(&ClosedListHead, &Bcb->BcbRemoveListEntry);
1176        }
1177     }
1178   }
1179   ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
1180 }
1181
1182 NTSTATUS STDCALL
1183 CcRosReleaseFileCache(PFILE_OBJECT FileObject)
1184 /*
1185  * FUNCTION: Called by the file system when a handle to a file object
1186  * has been closed.
1187  */
1188 {
1189   PBCB Bcb;
1190
1191   ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
1192
1193   if (FileObject->SectionObjectPointer->SharedCacheMap != NULL)
1194   {
1195     Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
1196     if (FileObject->PrivateCacheMap != NULL)
1197     {
1198       FileObject->PrivateCacheMap = NULL;
1199       if (Bcb->RefCount > 0)
1200       {
1201          Bcb->RefCount--;
1202          if (Bcb->RefCount == 0)
1203          {
1204             MmFreeSectionSegments(Bcb->FileObject);
1205             if (Bcb->RemoveOnClose)
1206             {
1207                CcRosDeleteFileCache(FileObject, Bcb);
1208             }
1209             else
1210             {
1211                Bcb->TimeStamp = CcTimeStamp;
1212                InsertHeadList(&ClosedListHead, &Bcb->BcbRemoveListEntry);
1213             }
1214          }
1215       }
1216     }
1217   }
1218   ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
1219   return(STATUS_SUCCESS);
1220 }
1221
1222 NTSTATUS
1223 NTAPI
1224 CcTryToInitializeFileCache(PFILE_OBJECT FileObject)
1225 {
1226    PBCB Bcb;
1227    NTSTATUS Status;
1228
1229    ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
1230
1231    Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
1232    if (Bcb == NULL)
1233    {
1234       Status = STATUS_UNSUCCESSFUL;
1235    }
1236    else
1237    {
1238       if (FileObject->PrivateCacheMap == NULL)
1239       {
1240          FileObject->PrivateCacheMap = Bcb;
1241          Bcb->RefCount++;
1242       }
1243       if (Bcb->BcbRemoveListEntry.Flink != NULL)
1244       {
1245          RemoveEntryList(&Bcb->BcbRemoveListEntry);
1246          Bcb->BcbRemoveListEntry.Flink = NULL;
1247       }
1248       Status = STATUS_SUCCESS;
1249    }
1250    ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
1251
1252    return Status;
1253 }
1254
1255
1256 NTSTATUS STDCALL
1257 CcRosInitializeFileCache(PFILE_OBJECT FileObject,
1258                          ULONG CacheSegmentSize)
1259 /*
1260  * FUNCTION: Initializes a BCB for a file object
1261  */
1262 {
1263    PBCB Bcb;
1264
1265    Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
1266    DPRINT("CcRosInitializeFileCache(FileObject 0x%p, Bcb 0x%p, CacheSegmentSize %d)\n",
1267            FileObject, Bcb, CacheSegmentSize);
1268
1269    ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
1270    if (Bcb == NULL)
1271    {
1272       Bcb = ExAllocateFromNPagedLookasideList(&BcbLookasideList);
1273       if (Bcb == NULL)
1274       {
1275         ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
1276         return(STATUS_UNSUCCESSFUL);
1277       }
1278       memset(Bcb, 0, sizeof(BCB));
1279       ObReferenceObjectByPointer(FileObject,
1280                                  FILE_ALL_ACCESS,
1281                                  NULL,
1282                                  KernelMode);
1283       Bcb->FileObject = FileObject;
1284       Bcb->CacheSegmentSize = CacheSegmentSize;
1285       if (FileObject->FsContext)
1286       {
1287          Bcb->AllocationSize =
1288            ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->AllocationSize;
1289          Bcb->FileSize =
1290            ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->FileSize;
1291       }
1292       KeInitializeSpinLock(&Bcb->BcbLock);
1293       InitializeListHead(&Bcb->BcbSegmentListHead);
1294       FileObject->SectionObjectPointer->SharedCacheMap = Bcb;
1295    }
1296    if (FileObject->PrivateCacheMap == NULL)
1297    {
1298       FileObject->PrivateCacheMap = Bcb;
1299       Bcb->RefCount++;
1300    }
1301    if (Bcb->BcbRemoveListEntry.Flink != NULL)
1302    {
1303       RemoveEntryList(&Bcb->BcbRemoveListEntry);
1304       Bcb->BcbRemoveListEntry.Flink = NULL;
1305    }
1306    ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
1307
1308    return(STATUS_SUCCESS);
1309 }
1310
1311 /*
1312  * @implemented
1313  */
1314 PFILE_OBJECT STDCALL
1315 CcGetFileObjectFromSectionPtrs(IN PSECTION_OBJECT_POINTERS SectionObjectPointers)
1316 {
1317    PBCB Bcb;
1318    if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
1319    {
1320       Bcb = (PBCB)SectionObjectPointers->SharedCacheMap;
1321       ASSERT(Bcb);
1322       return Bcb->FileObject;
1323    }
1324    return NULL;
1325 }
1326
1327 VOID STDCALL
1328 CmLazyCloseThreadMain(PVOID Ignored)
1329 {
1330    LARGE_INTEGER Timeout;
1331    PLIST_ENTRY current_entry;
1332    PBCB current;
1333    ULONG RemoveTimeStamp;
1334    NTSTATUS Status;
1335
1336    KeQuerySystemTime (&Timeout);
1337
1338    while (1)
1339    {
1340       Timeout.QuadPart += (LONGLONG)100000000; // 10sec
1341       Status = KeWaitForSingleObject(&LazyCloseThreadEvent,
1342                                      0,
1343                                      KernelMode,
1344                                      FALSE,
1345                                      &Timeout);
1346
1347       DPRINT("LazyCloseThreadMain %d\n", CcTimeStamp);
1348
1349       if (!NT_SUCCESS(Status))
1350       {
1351           DbgPrint("LazyCloseThread: Wait failed\n");
1352           KEBUGCHECKCC;
1353           break;
1354       }
1355       if (LazyCloseThreadShouldTerminate)
1356       {
1357           DbgPrint("LazyCloseThread: Terminating\n");
1358           break;
1359       }
1360
1361       ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock);
1362       CcTimeStamp++;
1363       if (CcTimeStamp >= 30)
1364       {
1365          RemoveTimeStamp = CcTimeStamp - 30; /* 5min = 10sec * 30 */
1366          while (!IsListEmpty(&ClosedListHead))
1367          {
1368             current_entry = ClosedListHead.Blink;
1369             current = CONTAINING_RECORD(current_entry, BCB, BcbRemoveListEntry);
1370             if (current->TimeStamp >= RemoveTimeStamp)
1371             {
1372                break;
1373             }
1374             CcRosDeleteFileCache(current->FileObject, current);
1375          }
1376       }
1377       ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock);
1378    }
1379 }
1380
1381 VOID
1382 INIT_FUNCTION
1383 NTAPI
1384 CcInitView(VOID)
1385 {
1386 #ifdef CACHE_BITMAP
1387   PMEMORY_AREA marea;
1388   PVOID Buffer;
1389   PHYSICAL_ADDRESS BoundaryAddressMultiple;
1390 #endif
1391   NTSTATUS Status;
1392   KPRIORITY Priority;
1393
1394   DPRINT("CcInitView()\n");
1395 #ifdef CACHE_BITMAP
1396   BoundaryAddressMultiple.QuadPart = 0;
1397   CiCacheSegMappingRegionHint = 0;
1398   CiCacheSegMappingRegionBase = NULL;
1399
1400   MmLockAddressSpace(MmGetKernelAddressSpace());
1401
1402   Status = MmCreateMemoryArea(MmGetKernelAddressSpace(),
1403                               MEMORY_AREA_CACHE_SEGMENT,
1404                               &CiCacheSegMappingRegionBase,
1405                               CI_CACHESEG_MAPPING_REGION_SIZE,
1406                               PAGE_READWRITE,
1407                               &marea,
1408                               FALSE,
1409                               0,
1410                               BoundaryAddressMultiple);
1411   MmUnlockAddressSpace(MmGetKernelAddressSpace());
1412   if (!NT_SUCCESS(Status))
1413     {
1414       KEBUGCHECKCC;
1415     }
1416
1417   Buffer = ExAllocatePool(NonPagedPool, CI_CACHESEG_MAPPING_REGION_SIZE / (PAGE_SIZE * 8));
1418
1419   RtlInitializeBitMap(&CiCacheSegMappingRegionAllocMap, Buffer, CI_CACHESEG_MAPPING_REGION_SIZE / PAGE_SIZE);
1420   RtlClearAllBits(&CiCacheSegMappingRegionAllocMap);
1421
1422   KeInitializeSpinLock(&CiCacheSegMappingRegionLock);
1423 #endif
1424   InitializeListHead(&CacheSegmentListHead);
1425   InitializeListHead(&DirtySegmentListHead);
1426   InitializeListHead(&CacheSegmentLRUListHead);
1427   InitializeListHead(&ClosedListHead);
1428   ExInitializeFastMutex(&ViewLock);
1429   ExInitializeNPagedLookasideList (&iBcbLookasideList,
1430                                    NULL,
1431                                    NULL,
1432                                    0,
1433                                    sizeof(INTERNAL_BCB),
1434                                    TAG_IBCB,
1435                                    20);
1436   ExInitializeNPagedLookasideList (&BcbLookasideList,
1437                                    NULL,
1438                                    NULL,
1439                                    0,
1440                                    sizeof(BCB),
1441                                    TAG_BCB,
1442                                    20);
1443   ExInitializeNPagedLookasideList (&CacheSegLookasideList,
1444                                    NULL,
1445                                    NULL,
1446                                    0,
1447                                    sizeof(CACHE_SEGMENT),
1448                                    TAG_CSEG,
1449                                    20);
1450
1451   MmInitializeMemoryConsumer(MC_CACHE, CcRosTrimCache);
1452
1453   CcInitCacheZeroPage();
1454
1455   CcTimeStamp = 0;
1456   LazyCloseThreadShouldTerminate = FALSE;
1457   KeInitializeEvent (&LazyCloseThreadEvent, SynchronizationEvent, FALSE);
1458   Status = PsCreateSystemThread(&LazyCloseThreadHandle,
1459                                 THREAD_ALL_ACCESS,
1460                                 NULL,
1461                                 NULL,
1462                                 &LazyCloseThreadId,
1463                                 (PKSTART_ROUTINE)CmLazyCloseThreadMain,
1464                                 NULL);
1465   if (NT_SUCCESS(Status))
1466   {
1467      Priority = LOW_REALTIME_PRIORITY;
1468      NtSetInformationThread(LazyCloseThreadHandle,
1469                             ThreadPriority,
1470                             &Priority,
1471                             sizeof(Priority));
1472   }
1473
1474 }
1475
1476 /* EOF */
1477
1478
1479
1480
1481
1482
1483