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