3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS kernel
5 * FILE: ntoskrnl/cc/view.c
6 * PURPOSE: Cache manager
8 * PROGRAMMERS: David Welch (welch@mcmail.com)
11 /* NOTES **********************************************************************
13 * This is not the NT implementation of a file cache nor anything much like
16 * The general procedure for a filesystem to implement a read or write
17 * dispatch routine is as follows
19 * (1) If caching for the FCB hasn't been initiated then so do by calling
20 * CcInitializeFileCache.
22 * (2) For each 4k region which is being read or written obtain a cache page
23 * by calling CcRequestCachePage.
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.
29 * (4) Copy the data into or out of the page as necessary.
31 * (5) Release the cache page
33 /* INCLUDES ******************************************************************/
37 #include <internal/debug.h>
39 /* GLOBALS *******************************************************************/
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).
47 //#define CACHE_BITMAP
49 static LIST_ENTRY DirtySegmentListHead
;
50 static LIST_ENTRY CacheSegmentListHead
;
51 static LIST_ENTRY CacheSegmentLRUListHead
;
52 static LIST_ENTRY ClosedListHead
;
53 ULONG DirtyPageCount
=0;
58 #define CI_CACHESEG_MAPPING_REGION_SIZE (128*1024*1024)
60 static PVOID CiCacheSegMappingRegionBase
= NULL
;
61 static RTL_BITMAP CiCacheSegMappingRegionAllocMap
;
62 static ULONG CiCacheSegMappingRegionHint
;
63 static KSPIN_LOCK CiCacheSegMappingRegionLock
;
66 NPAGED_LOOKASIDE_LIST iBcbLookasideList
;
67 static NPAGED_LOOKASIDE_LIST BcbLookasideList
;
68 static NPAGED_LOOKASIDE_LIST CacheSegLookasideList
;
70 static ULONG CcTimeStamp
;
71 static KEVENT LazyCloseThreadEvent
;
72 static HANDLE LazyCloseThreadHandle
;
73 static CLIENT_ID LazyCloseThreadId
;
74 static volatile BOOLEAN LazyCloseThreadShouldTerminate
;
77 /* void * alloca(size_t size); */
78 #elif defined(_MSC_VER)
79 void* _alloca(size_t size
);
81 #error Unknown compiler for alloca intrinsic stack allocation "function"
84 #if defined(DBG) || defined(KDBG)
85 static void CcRosCacheSegmentIncRefCount_ ( PCACHE_SEGMENT cs
, const char* file
, int line
)
90 DbgPrint("(%s:%i) CacheSegment %p ++RefCount=%d, Dirty %d, PageOut %d\n",
91 file
, line
, cs
, cs
->ReferenceCount
, cs
->Dirty
, cs
->PageOut
);
94 static void CcRosCacheSegmentDecRefCount_ ( PCACHE_SEGMENT cs
, const char* file
, int line
)
99 DbgPrint("(%s:%i) CacheSegment %p --RefCount=%d, Dirty %d, PageOut %d\n",
100 file
, line
, cs
, cs
->ReferenceCount
, cs
->Dirty
, cs
->PageOut
);
103 #define CcRosCacheSegmentIncRefCount(cs) CcRosCacheSegmentIncRefCount_(cs,__FILE__,__LINE__)
104 #define CcRosCacheSegmentDecRefCount(cs) CcRosCacheSegmentDecRefCount_(cs,__FILE__,__LINE__)
106 #define CcRosCacheSegmentIncRefCount(cs) (++((cs)->ReferenceCount))
107 #define CcRosCacheSegmentDecRefCount(cs) (--((cs)->ReferenceCount))
111 CcRosInternalFreeCacheSegment(PCACHE_SEGMENT CacheSeg
);
115 CcTryToAcquireBrokenMutex(PFAST_MUTEX FastMutex
)
117 KeEnterCriticalRegion();
118 if (InterlockedCompareExchange(&FastMutex
->Count
, 0, 1) == 1)
120 FastMutex
->Owner
= KeGetCurrentThread();
125 KeLeaveCriticalRegion();
130 /* FUNCTIONS *****************************************************************/
138 #if defined(DBG) || defined(KDBG)
140 PLIST_ENTRY current_entry
;
141 PCACHE_SEGMENT current
;
150 DPRINT1("Enabling Tracing for CacheMap 0x%p:\n", Bcb
);
152 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
153 KeAcquireSpinLock(&Bcb
->BcbLock
, &oldirql
);
155 current_entry
= Bcb
->BcbSegmentListHead
.Flink
;
156 while (current_entry
!= &Bcb
->BcbSegmentListHead
)
158 current
= CONTAINING_RECORD(current_entry
, CACHE_SEGMENT
, BcbSegmentListEntry
);
159 current_entry
= current_entry
->Flink
;
161 DPRINT1(" CacheSegment 0x%p enabled, RefCount %d, Dirty %d, PageOut %d\n",
162 current
, current
->ReferenceCount
, current
->Dirty
, current
->PageOut
);
164 KeReleaseSpinLock(&Bcb
->BcbLock
, oldirql
);
165 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
169 DPRINT1("Disabling Tracing for CacheMap 0x%p:\n", Bcb
);
180 CcRosFlushCacheSegment(PCACHE_SEGMENT CacheSegment
)
184 Status
= WriteCacheSegment(CacheSegment
);
185 if (NT_SUCCESS(Status
))
187 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
188 KeAcquireSpinLock(&CacheSegment
->Bcb
->BcbLock
, &oldIrql
);
189 CacheSegment
->Dirty
= FALSE
;
190 RemoveEntryList(&CacheSegment
->DirtySegmentListEntry
);
191 DirtyPageCount
-= CacheSegment
->Bcb
->CacheSegmentSize
/ PAGE_SIZE
;
192 CcRosCacheSegmentDecRefCount ( CacheSegment
);
193 KeReleaseSpinLock(&CacheSegment
->Bcb
->BcbLock
, oldIrql
);
194 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
201 CcRosFlushDirtyPages(ULONG Target
, PULONG Count
)
203 PLIST_ENTRY current_entry
;
204 PCACHE_SEGMENT current
;
205 ULONG PagesPerSegment
;
208 static ULONG WriteCount
[4] = {0, 0, 0, 0};
211 DPRINT("CcRosFlushDirtyPages(Target %d)\n", Target
);
215 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
217 WriteCount
[0] = WriteCount
[1];
218 WriteCount
[1] = WriteCount
[2];
219 WriteCount
[2] = WriteCount
[3];
222 NewTarget
= WriteCount
[0] + WriteCount
[1] + WriteCount
[2];
224 if (NewTarget
< DirtyPageCount
)
226 NewTarget
= (DirtyPageCount
- NewTarget
+ 3) / 4;
227 WriteCount
[0] += NewTarget
;
228 WriteCount
[1] += NewTarget
;
229 WriteCount
[2] += NewTarget
;
230 WriteCount
[3] += NewTarget
;
233 NewTarget
= WriteCount
[0];
235 Target
= max(NewTarget
, Target
);
237 current_entry
= DirtySegmentListHead
.Flink
;
238 if (current_entry
== &DirtySegmentListHead
)
240 DPRINT("No Dirty pages\n");
242 while (current_entry
!= &DirtySegmentListHead
&& Target
> 0)
244 current
= CONTAINING_RECORD(current_entry
, CACHE_SEGMENT
,
245 DirtySegmentListEntry
);
246 current_entry
= current_entry
->Flink
;
247 Locked
= CcTryToAcquireBrokenMutex(¤t
->Lock
);
252 ASSERT(current
->Dirty
);
253 if (current
->ReferenceCount
> 1)
255 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(¤t
->Lock
);
258 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
259 PagesPerSegment
= current
->Bcb
->CacheSegmentSize
/ PAGE_SIZE
;
260 Status
= CcRosFlushCacheSegment(current
);
261 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(¤t
->Lock
);
262 if (!NT_SUCCESS(Status
) && (Status
!= STATUS_END_OF_FILE
))
264 DPRINT1("CC: Failed to flush cache segment.\n");
268 (*Count
) += PagesPerSegment
;
269 Target
-= PagesPerSegment
;
271 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
272 current_entry
= DirtySegmentListHead
.Flink
;
274 if (*Count
< NewTarget
)
276 WriteCount
[1] += (NewTarget
- *Count
);
278 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
279 DPRINT("CcRosFlushDirtyPages() finished\n");
281 return(STATUS_SUCCESS
);
285 CcRosTrimCache(ULONG Target
, ULONG Priority
, PULONG NrFreed
)
287 * FUNCTION: Try to free some memory from the file cache.
289 * Target - The number of pages to be freed.
290 * Priority - The priority of free (currently unused).
291 * NrFreed - Points to a variable where the number of pages
292 * actually freed is returned.
295 PLIST_ENTRY current_entry
;
296 PCACHE_SEGMENT current
, last
= NULL
;
297 ULONG PagesPerSegment
;
302 DPRINT("CcRosTrimCache(Target %d)\n", Target
);
306 InitializeListHead(&FreeList
);
308 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
309 current_entry
= CacheSegmentLRUListHead
.Flink
;
310 while (current_entry
!= &CacheSegmentLRUListHead
&& Target
> 0)
312 current
= CONTAINING_RECORD(current_entry
, CACHE_SEGMENT
,
313 CacheSegmentLRUListEntry
);
314 current_entry
= current_entry
->Flink
;
316 KeAcquireSpinLock(¤t
->Bcb
->BcbLock
, &oldIrql
);
317 if (current
->ReferenceCount
== 0)
319 RemoveEntryList(¤t
->BcbSegmentListEntry
);
320 KeReleaseSpinLock(¤t
->Bcb
->BcbLock
, oldIrql
);
321 RemoveEntryList(¤t
->CacheSegmentListEntry
);
322 RemoveEntryList(¤t
->CacheSegmentLRUListEntry
);
323 InsertHeadList(&FreeList
, ¤t
->BcbSegmentListEntry
);
324 PagesPerSegment
= current
->Bcb
->CacheSegmentSize
/ PAGE_SIZE
;
325 PagesFreed
= min(PagesPerSegment
, Target
);
326 Target
-= PagesFreed
;
327 (*NrFreed
) += PagesFreed
;
331 if (last
!= current
&& current
->MappedCount
> 0 && !current
->Dirty
&& !current
->PageOut
)
336 CcRosCacheSegmentIncRefCount(current
);
338 current
->PageOut
= TRUE
;
339 KeReleaseSpinLock(¤t
->Bcb
->BcbLock
, oldIrql
);
340 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
341 for (i
= 0; i
< current
->Bcb
->CacheSegmentSize
/ PAGE_SIZE
; i
++)
344 Page
= MmGetPhysicalAddress((char*)current
->BaseAddress
+ i
* PAGE_SIZE
).QuadPart
>> PAGE_SHIFT
;
345 Status
= MmPageOutPhysicalAddress(Page
);
346 if (!NT_SUCCESS(Status
))
351 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
352 KeAcquireSpinLock(¤t
->Bcb
->BcbLock
, &oldIrql
);
353 CcRosCacheSegmentDecRefCount(current
);
354 current
->PageOut
= FALSE
;
355 KeReleaseSpinLock(¤t
->Bcb
->BcbLock
, oldIrql
);
356 current_entry
= ¤t
->CacheSegmentLRUListEntry
;
359 KeReleaseSpinLock(¤t
->Bcb
->BcbLock
, oldIrql
);
362 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
364 while (!IsListEmpty(&FreeList
))
366 current_entry
= RemoveHeadList(&FreeList
);
367 current
= CONTAINING_RECORD(current_entry
, CACHE_SEGMENT
,
368 BcbSegmentListEntry
);
369 CcRosInternalFreeCacheSegment(current
);
372 DPRINT("CcRosTrimCache() finished\n");
373 return(STATUS_SUCCESS
);
378 CcRosReleaseCacheSegment(PBCB Bcb
,
379 PCACHE_SEGMENT CacheSeg
,
384 BOOLEAN WasDirty
= CacheSeg
->Dirty
;
389 DPRINT("CcReleaseCacheSegment(Bcb 0x%p, CacheSeg 0x%p, Valid %d)\n",
390 Bcb
, CacheSeg
, Valid
);
392 CacheSeg
->Valid
= Valid
;
393 CacheSeg
->Dirty
= CacheSeg
->Dirty
|| Dirty
;
395 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
396 if (!WasDirty
&& CacheSeg
->Dirty
)
398 InsertTailList(&DirtySegmentListHead
, &CacheSeg
->DirtySegmentListEntry
);
399 DirtyPageCount
+= Bcb
->CacheSegmentSize
/ PAGE_SIZE
;
401 RemoveEntryList(&CacheSeg
->CacheSegmentLRUListEntry
);
402 InsertTailList(&CacheSegmentLRUListHead
, &CacheSeg
->CacheSegmentLRUListEntry
);
406 CacheSeg
->MappedCount
++;
408 KeAcquireSpinLock(&Bcb
->BcbLock
, &oldIrql
);
409 CcRosCacheSegmentDecRefCount(CacheSeg
);
410 if (Mapped
&& CacheSeg
->MappedCount
== 1)
412 CcRosCacheSegmentIncRefCount(CacheSeg
);
414 if (!WasDirty
&& CacheSeg
->Dirty
)
416 CcRosCacheSegmentIncRefCount(CacheSeg
);
418 KeReleaseSpinLock(&Bcb
->BcbLock
, oldIrql
);
419 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
420 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&CacheSeg
->Lock
);
422 return(STATUS_SUCCESS
);
427 CcRosLookupCacheSegment(PBCB Bcb
, ULONG FileOffset
)
429 PLIST_ENTRY current_entry
;
430 PCACHE_SEGMENT current
;
435 DPRINT("CcRosLookupCacheSegment(Bcb -x%p, FileOffset %d)\n", Bcb
, FileOffset
);
437 KeAcquireSpinLock(&Bcb
->BcbLock
, &oldIrql
);
438 current_entry
= Bcb
->BcbSegmentListHead
.Flink
;
439 while (current_entry
!= &Bcb
->BcbSegmentListHead
)
441 current
= CONTAINING_RECORD(current_entry
, CACHE_SEGMENT
,
442 BcbSegmentListEntry
);
443 if (current
->FileOffset
<= FileOffset
&&
444 (current
->FileOffset
+ Bcb
->CacheSegmentSize
) > FileOffset
)
446 CcRosCacheSegmentIncRefCount(current
);
447 KeReleaseSpinLock(&Bcb
->BcbLock
, oldIrql
);
448 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(¤t
->Lock
);
451 current_entry
= current_entry
->Flink
;
453 KeReleaseSpinLock(&Bcb
->BcbLock
, oldIrql
);
459 CcRosMarkDirtyCacheSegment(PBCB Bcb
, ULONG FileOffset
)
461 PCACHE_SEGMENT CacheSeg
;
466 DPRINT("CcRosMarkDirtyCacheSegment(Bcb 0x%p, FileOffset %d)\n", Bcb
, FileOffset
);
468 CacheSeg
= CcRosLookupCacheSegment(Bcb
, FileOffset
);
469 if (CacheSeg
== NULL
)
473 if (!CacheSeg
->Dirty
)
475 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
476 InsertTailList(&DirtySegmentListHead
, &CacheSeg
->DirtySegmentListEntry
);
477 DirtyPageCount
+= Bcb
->CacheSegmentSize
/ PAGE_SIZE
;
478 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
482 KeAcquireSpinLock(&Bcb
->BcbLock
, &oldIrql
);
483 CcRosCacheSegmentDecRefCount(CacheSeg
);
484 KeReleaseSpinLock(&Bcb
->BcbLock
, oldIrql
);
488 CacheSeg
->Dirty
= TRUE
;
489 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&CacheSeg
->Lock
);
491 return(STATUS_SUCCESS
);
496 CcRosUnmapCacheSegment(PBCB Bcb
, ULONG FileOffset
, BOOLEAN NowDirty
)
498 PCACHE_SEGMENT CacheSeg
;
504 DPRINT("CcRosUnmapCacheSegment(Bcb 0x%p, FileOffset %d, NowDirty %d)\n",
505 Bcb
, FileOffset
, NowDirty
);
507 CacheSeg
= CcRosLookupCacheSegment(Bcb
, FileOffset
);
508 if (CacheSeg
== NULL
)
510 return(STATUS_UNSUCCESSFUL
);
513 WasDirty
= CacheSeg
->Dirty
;
514 CacheSeg
->Dirty
= CacheSeg
->Dirty
|| NowDirty
;
516 CacheSeg
->MappedCount
--;
518 if (!WasDirty
&& NowDirty
)
520 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
521 InsertTailList(&DirtySegmentListHead
, &CacheSeg
->DirtySegmentListEntry
);
522 DirtyPageCount
+= Bcb
->CacheSegmentSize
/ PAGE_SIZE
;
523 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
526 KeAcquireSpinLock(&Bcb
->BcbLock
, &oldIrql
);
527 CcRosCacheSegmentDecRefCount(CacheSeg
);
528 if (!WasDirty
&& NowDirty
)
530 CcRosCacheSegmentIncRefCount(CacheSeg
);
532 if (CacheSeg
->MappedCount
== 0)
534 CcRosCacheSegmentDecRefCount(CacheSeg
);
536 KeReleaseSpinLock(&Bcb
->BcbLock
, oldIrql
);
538 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&CacheSeg
->Lock
);
539 return(STATUS_SUCCESS
);
543 CcRosCreateCacheSegment(PBCB Bcb
,
545 PCACHE_SEGMENT
* CacheSeg
)
548 PCACHE_SEGMENT current
;
549 PCACHE_SEGMENT previous
;
550 PLIST_ENTRY current_entry
;
555 ULONG StartingOffset
;
558 PHYSICAL_ADDRESS BoundaryAddressMultiple
;
562 DPRINT("CcRosCreateCacheSegment()\n");
564 BoundaryAddressMultiple
.QuadPart
= 0;
565 if (FileOffset
>= Bcb
->FileSize
.u
.LowPart
)
568 return STATUS_INVALID_PARAMETER
;
571 current
= ExAllocateFromNPagedLookasideList(&CacheSegLookasideList
);
572 current
->Valid
= FALSE
;
573 current
->Dirty
= FALSE
;
574 current
->PageOut
= FALSE
;
575 current
->FileOffset
= ROUND_DOWN(FileOffset
, Bcb
->CacheSegmentSize
);
577 #if defined(DBG) || defined(KDBG)
580 DPRINT1("CacheMap 0x%p: new Cache Segment: 0x%p\n", Bcb
, current
);
583 current
->MappedCount
= 0;
584 current
->DirtySegmentListEntry
.Flink
= NULL
;
585 current
->DirtySegmentListEntry
.Blink
= NULL
;
586 current
->ReferenceCount
= 1;
587 ExInitializeFastMutex(¤t
->Lock
);
588 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(¤t
->Lock
);
589 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
592 /* There is window between the call to CcRosLookupCacheSegment
593 * and CcRosCreateCacheSegment. We must check if a segment on
594 * the fileoffset exist. If there exist a segment, we release
595 * our new created segment and return the existing one.
597 KeAcquireSpinLock(&Bcb
->BcbLock
, &oldIrql
);
598 current_entry
= Bcb
->BcbSegmentListHead
.Flink
;
600 while (current_entry
!= &Bcb
->BcbSegmentListHead
)
602 current
= CONTAINING_RECORD(current_entry
, CACHE_SEGMENT
,
603 BcbSegmentListEntry
);
604 if (current
->FileOffset
<= FileOffset
&&
605 (current
->FileOffset
+ Bcb
->CacheSegmentSize
) > FileOffset
)
607 CcRosCacheSegmentIncRefCount(current
);
608 KeReleaseSpinLock(&Bcb
->BcbLock
, oldIrql
);
609 #if defined(DBG) || defined(KDBG)
612 DPRINT1("CacheMap 0x%p: deleting newly created Cache Segment 0x%p ( found existing one 0x%p )\n",
618 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&(*CacheSeg
)->Lock
);
619 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
620 ExFreeToNPagedLookasideList(&CacheSegLookasideList
, *CacheSeg
);
622 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(¤t
->Lock
);
623 return STATUS_SUCCESS
;
625 if (current
->FileOffset
< FileOffset
)
627 if (previous
== NULL
)
633 if (previous
->FileOffset
< current
->FileOffset
)
639 current_entry
= current_entry
->Flink
;
641 /* There was no existing segment. */
645 InsertHeadList(&previous
->BcbSegmentListEntry
, ¤t
->BcbSegmentListEntry
);
649 InsertHeadList(&Bcb
->BcbSegmentListHead
, ¤t
->BcbSegmentListEntry
);
651 KeReleaseSpinLock(&Bcb
->BcbLock
, oldIrql
);
652 InsertTailList(&CacheSegmentListHead
, ¤t
->CacheSegmentListEntry
);
653 InsertTailList(&CacheSegmentLRUListHead
, ¤t
->CacheSegmentLRUListEntry
);
654 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
656 KeAcquireSpinLock(&CiCacheSegMappingRegionLock
, &oldIrql
);
658 StartingOffset
= RtlFindClearBitsAndSet(&CiCacheSegMappingRegionAllocMap
, Bcb
->CacheSegmentSize
/ PAGE_SIZE
, CiCacheSegMappingRegionHint
);
660 if (StartingOffset
== 0xffffffff)
662 DPRINT1("Out of CacheSeg mapping space\n");
666 current
->BaseAddress
= CiCacheSegMappingRegionBase
+ StartingOffset
* PAGE_SIZE
;
668 if (CiCacheSegMappingRegionHint
== StartingOffset
)
670 CiCacheSegMappingRegionHint
+= Bcb
->CacheSegmentSize
/ PAGE_SIZE
;
673 KeReleaseSpinLock(&CiCacheSegMappingRegionLock
, oldIrql
);
675 MmLockAddressSpace(MmGetKernelAddressSpace());
676 current
->BaseAddress
= NULL
;
677 Status
= MmCreateMemoryArea(MmGetKernelAddressSpace(),
678 MEMORY_AREA_CACHE_SEGMENT
,
679 ¤t
->BaseAddress
,
680 Bcb
->CacheSegmentSize
,
682 (PMEMORY_AREA
*)¤t
->MemoryArea
,
685 BoundaryAddressMultiple
);
686 MmUnlockAddressSpace(MmGetKernelAddressSpace());
687 if (!NT_SUCCESS(Status
))
692 Pfn
= alloca(sizeof(PFN_TYPE
) * (Bcb
->CacheSegmentSize
/ PAGE_SIZE
));
693 for (i
= 0; i
< (Bcb
->CacheSegmentSize
/ PAGE_SIZE
); i
++)
695 Status
= MmRequestPageMemoryConsumer(MC_CACHE
, TRUE
, &Pfn
[i
]);
696 if (!NT_SUCCESS(Status
))
701 Status
= MmCreateVirtualMapping(NULL
,
702 current
->BaseAddress
,
705 Bcb
->CacheSegmentSize
/ PAGE_SIZE
);
706 if (!NT_SUCCESS(Status
))
710 return(STATUS_SUCCESS
);
715 CcRosGetCacheSegmentChain(PBCB Bcb
,
718 PCACHE_SEGMENT
* CacheSeg
)
720 PCACHE_SEGMENT current
;
722 PCACHE_SEGMENT
* CacheSegList
;
723 PCACHE_SEGMENT Previous
= NULL
;
727 DPRINT("CcRosGetCacheSegmentChain()\n");
729 Length
= ROUND_UP(Length
, Bcb
->CacheSegmentSize
);
731 #if defined(__GNUC__)
732 CacheSegList
= alloca(sizeof(PCACHE_SEGMENT
) *
733 (Length
/ Bcb
->CacheSegmentSize
));
734 #elif defined(_MSC_VER)
735 CacheSegList
= _alloca(sizeof(PCACHE_SEGMENT
) *
736 (Length
/ Bcb
->CacheSegmentSize
));
738 #error Unknown compiler for alloca intrinsic stack allocation "function"
742 * Look for a cache segment already mapping the same data.
744 for (i
= 0; i
< (Length
/ Bcb
->CacheSegmentSize
); i
++)
746 ULONG CurrentOffset
= FileOffset
+ (i
* Bcb
->CacheSegmentSize
);
747 current
= CcRosLookupCacheSegment(Bcb
, CurrentOffset
);
750 CacheSegList
[i
] = current
;
754 CcRosCreateCacheSegment(Bcb
, CurrentOffset
, ¤t
);
755 CacheSegList
[i
] = current
;
759 for (i
= 0; i
< (Length
/ Bcb
->CacheSegmentSize
); i
++)
763 *CacheSeg
= CacheSegList
[i
];
764 Previous
= CacheSegList
[i
];
768 Previous
->NextInChain
= CacheSegList
[i
];
769 Previous
= CacheSegList
[i
];
772 Previous
->NextInChain
= NULL
;
774 return(STATUS_SUCCESS
);
779 CcRosGetCacheSegment(PBCB Bcb
,
784 PCACHE_SEGMENT
* CacheSeg
)
786 PCACHE_SEGMENT current
;
791 DPRINT("CcRosGetCacheSegment()\n");
794 * Look for a cache segment already mapping the same data.
796 current
= CcRosLookupCacheSegment(Bcb
, FileOffset
);
800 * Otherwise create a new segment.
802 Status
= CcRosCreateCacheSegment(Bcb
, FileOffset
, ¤t
);
803 if (!NT_SUCCESS(Status
))
809 * Return information about the segment to the caller.
811 *UptoDate
= current
->Valid
;
812 *BaseAddress
= current
->BaseAddress
;
813 DPRINT("*BaseAddress 0x%.8X\n", *BaseAddress
);
815 *BaseOffset
= current
->FileOffset
;
816 return(STATUS_SUCCESS
);
820 CcRosRequestCacheSegment(PBCB Bcb
,
824 PCACHE_SEGMENT
* CacheSeg
)
826 * FUNCTION: Request a page mapping for a BCB
833 if ((FileOffset
% Bcb
->CacheSegmentSize
) != 0)
835 CPRINT("Bad fileoffset %x should be multiple of %x",
836 FileOffset
, Bcb
->CacheSegmentSize
);
840 return(CcRosGetCacheSegment(Bcb
,
850 CcFreeCachePage(PVOID Context
, MEMORY_AREA
* MemoryArea
, PVOID Address
,
851 PFN_TYPE Page
, SWAPENTRY SwapEntry
, BOOLEAN Dirty
)
853 ASSERT(SwapEntry
== 0);
856 MmReleasePageMemoryConsumer(MC_CACHE
, Page
);
861 CcRosInternalFreeCacheSegment(PCACHE_SEGMENT CacheSeg
)
863 * FUNCTION: Releases a cache segment associated with a BCB
873 DPRINT("Freeing cache segment 0x%p\n", CacheSeg
);
874 #if defined(DBG) || defined(KDBG)
875 if ( CacheSeg
->Bcb
->Trace
)
877 DPRINT1("CacheMap 0x%p: deleting Cache Segment: 0x%p\n", CacheSeg
->Bcb
, CacheSeg
);
881 RegionSize
= CacheSeg
->Bcb
->CacheSegmentSize
/ PAGE_SIZE
;
883 /* Unmap all the pages. */
884 for (i
= 0; i
< RegionSize
; i
++)
886 MmDeleteVirtualMapping(NULL
,
887 CacheSeg
->BaseAddress
+ (i
* PAGE_SIZE
),
891 MmReleasePageMemoryConsumer(MC_CACHE
, Page
);
894 KeAcquireSpinLock(&CiCacheSegMappingRegionLock
, &oldIrql
);
895 /* Deallocate all the pages used. */
896 Base
= (ULONG
)(CacheSeg
->BaseAddress
- CiCacheSegMappingRegionBase
) / PAGE_SIZE
;
898 RtlClearBits(&CiCacheSegMappingRegionAllocMap
, Base
, RegionSize
);
900 CiCacheSegMappingRegionHint
= min (CiCacheSegMappingRegionHint
, Base
);
902 KeReleaseSpinLock(&CiCacheSegMappingRegionLock
, oldIrql
);
904 MmLockAddressSpace(MmGetKernelAddressSpace());
905 MmFreeMemoryArea(MmGetKernelAddressSpace(),
906 CacheSeg
->MemoryArea
,
909 MmUnlockAddressSpace(MmGetKernelAddressSpace());
911 ExFreeToNPagedLookasideList(&CacheSegLookasideList
, CacheSeg
);
912 return(STATUS_SUCCESS
);
917 CcRosFreeCacheSegment(PBCB Bcb
, PCACHE_SEGMENT CacheSeg
)
924 DPRINT("CcRosFreeCacheSegment(Bcb 0x%p, CacheSeg 0x%p)\n",
927 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
928 KeAcquireSpinLock(&Bcb
->BcbLock
, &oldIrql
);
929 RemoveEntryList(&CacheSeg
->BcbSegmentListEntry
);
930 RemoveEntryList(&CacheSeg
->CacheSegmentListEntry
);
931 RemoveEntryList(&CacheSeg
->CacheSegmentLRUListEntry
);
934 RemoveEntryList(&CacheSeg
->DirtySegmentListEntry
);
935 DirtyPageCount
-= Bcb
->CacheSegmentSize
/ PAGE_SIZE
;
938 KeReleaseSpinLock(&Bcb
->BcbLock
, oldIrql
);
939 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
941 Status
= CcRosInternalFreeCacheSegment(CacheSeg
);
949 CcFlushCache(IN PSECTION_OBJECT_POINTERS SectionObjectPointers
,
950 IN PLARGE_INTEGER FileOffset OPTIONAL
,
952 OUT PIO_STATUS_BLOCK IoStatus
)
955 LARGE_INTEGER Offset
;
956 PCACHE_SEGMENT current
;
960 DPRINT("CcFlushCache(SectionObjectPointers 0x%p, FileOffset 0x%p, Length %d, IoStatus 0x%p)\n",
961 SectionObjectPointers
, FileOffset
, Length
, IoStatus
);
963 if (SectionObjectPointers
&& SectionObjectPointers
->SharedCacheMap
)
965 Bcb
= (PBCB
)SectionObjectPointers
->SharedCacheMap
;
969 Offset
= *FileOffset
;
973 Offset
.QuadPart
= (LONGLONG
)0;
974 Length
= Bcb
->FileSize
.u
.LowPart
;
979 IoStatus
->Status
= STATUS_SUCCESS
;
980 IoStatus
->Information
= 0;
985 current
= CcRosLookupCacheSegment (Bcb
, Offset
.u
.LowPart
);
990 Status
= CcRosFlushCacheSegment(current
);
991 if (!NT_SUCCESS(Status
) && IoStatus
!= NULL
)
993 IoStatus
->Status
= Status
;
996 KeAcquireSpinLock(&Bcb
->BcbLock
, &oldIrql
);
997 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(¤t
->Lock
);
998 CcRosCacheSegmentDecRefCount(current
);
999 KeReleaseSpinLock(&Bcb
->BcbLock
, oldIrql
);
1002 Offset
.QuadPart
+= Bcb
->CacheSegmentSize
;
1003 if (Length
> Bcb
->CacheSegmentSize
)
1005 Length
-= Bcb
->CacheSegmentSize
;
1017 IoStatus
->Status
= STATUS_INVALID_PARAMETER
;
1024 CcRosDeleteFileCache(PFILE_OBJECT FileObject
, PBCB Bcb
)
1026 * FUNCTION: Releases the BCB associated with a file object
1029 PLIST_ENTRY current_entry
;
1030 PCACHE_SEGMENT current
;
1032 LIST_ENTRY FreeList
;
1038 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
1040 CcFlushCache(FileObject
->SectionObjectPointer
, NULL
, 0, NULL
);
1042 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
1044 if (Bcb
->RefCount
== 0)
1046 if (Bcb
->BcbRemoveListEntry
.Flink
!= NULL
)
1048 RemoveEntryList(&Bcb
->BcbRemoveListEntry
);
1049 Bcb
->BcbRemoveListEntry
.Flink
= NULL
;
1052 FileObject
->SectionObjectPointer
->SharedCacheMap
= NULL
;
1055 * Release all cache segments.
1057 InitializeListHead(&FreeList
);
1058 KeAcquireSpinLock(&Bcb
->BcbLock
, &oldIrql
);
1059 current_entry
= Bcb
->BcbSegmentListHead
.Flink
;
1060 while (!IsListEmpty(&Bcb
->BcbSegmentListHead
))
1062 current_entry
= RemoveTailList(&Bcb
->BcbSegmentListHead
);
1063 current
= CONTAINING_RECORD(current_entry
, CACHE_SEGMENT
, BcbSegmentListEntry
);
1064 RemoveEntryList(¤t
->CacheSegmentListEntry
);
1065 RemoveEntryList(¤t
->CacheSegmentLRUListEntry
);
1068 RemoveEntryList(¤t
->DirtySegmentListEntry
);
1069 DirtyPageCount
-= Bcb
->CacheSegmentSize
/ PAGE_SIZE
;
1070 DPRINT1("Freeing dirty segment\n");
1072 InsertHeadList(&FreeList
, ¤t
->BcbSegmentListEntry
);
1074 #if defined(DBG) || defined(KDBG)
1077 KeReleaseSpinLock(&Bcb
->BcbLock
, oldIrql
);
1079 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
1080 ObDereferenceObject (Bcb
->FileObject
);
1082 while (!IsListEmpty(&FreeList
))
1084 current_entry
= RemoveTailList(&FreeList
);
1085 current
= CONTAINING_RECORD(current_entry
, CACHE_SEGMENT
, BcbSegmentListEntry
);
1086 Status
= CcRosInternalFreeCacheSegment(current
);
1088 ExFreeToNPagedLookasideList(&BcbLookasideList
, Bcb
);
1089 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
1091 return(STATUS_SUCCESS
);
1096 CcRosReferenceCache(PFILE_OBJECT FileObject
)
1099 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
1100 Bcb
= (PBCB
)FileObject
->SectionObjectPointer
->SharedCacheMap
;
1102 if (Bcb
->RefCount
== 0)
1104 ASSERT(Bcb
->BcbRemoveListEntry
.Flink
!= NULL
);
1105 RemoveEntryList(&Bcb
->BcbRemoveListEntry
);
1106 Bcb
->BcbRemoveListEntry
.Flink
= NULL
;
1111 ASSERT(Bcb
->BcbRemoveListEntry
.Flink
== NULL
);
1114 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
1119 CcRosSetRemoveOnClose(PSECTION_OBJECT_POINTERS SectionObjectPointer
)
1122 DPRINT("CcRosSetRemoveOnClose()\n");
1123 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
1124 Bcb
= (PBCB
)SectionObjectPointer
->SharedCacheMap
;
1127 Bcb
->RemoveOnClose
= TRUE
;
1128 if (Bcb
->RefCount
== 0)
1130 CcRosDeleteFileCache(Bcb
->FileObject
, Bcb
);
1133 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
1139 CcRosDereferenceCache(PFILE_OBJECT FileObject
)
1142 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
1143 Bcb
= (PBCB
)FileObject
->SectionObjectPointer
->SharedCacheMap
;
1145 if (Bcb
->RefCount
> 0)
1148 if (Bcb
->RefCount
== 0)
1150 MmFreeSectionSegments(Bcb
->FileObject
);
1151 if (Bcb
->RemoveOnClose
)
1153 CcRosDeleteFileCache(FileObject
, Bcb
);
1157 Bcb
->TimeStamp
= CcTimeStamp
;
1158 InsertHeadList(&ClosedListHead
, &Bcb
->BcbRemoveListEntry
);
1162 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
1166 CcRosReleaseFileCache(PFILE_OBJECT FileObject
)
1168 * FUNCTION: Called by the file system when a handle to a file object
1174 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
1176 if (FileObject
->SectionObjectPointer
->SharedCacheMap
!= NULL
)
1178 Bcb
= FileObject
->SectionObjectPointer
->SharedCacheMap
;
1179 if (FileObject
->PrivateCacheMap
!= NULL
)
1181 FileObject
->PrivateCacheMap
= NULL
;
1182 if (Bcb
->RefCount
> 0)
1185 if (Bcb
->RefCount
== 0)
1187 MmFreeSectionSegments(Bcb
->FileObject
);
1188 if (Bcb
->RemoveOnClose
)
1190 CcRosDeleteFileCache(FileObject
, Bcb
);
1194 Bcb
->TimeStamp
= CcTimeStamp
;
1195 InsertHeadList(&ClosedListHead
, &Bcb
->BcbRemoveListEntry
);
1201 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
1202 return(STATUS_SUCCESS
);
1207 CcTryToInitializeFileCache(PFILE_OBJECT FileObject
)
1212 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
1214 Bcb
= FileObject
->SectionObjectPointer
->SharedCacheMap
;
1217 Status
= STATUS_UNSUCCESSFUL
;
1221 if (FileObject
->PrivateCacheMap
== NULL
)
1223 FileObject
->PrivateCacheMap
= Bcb
;
1226 if (Bcb
->BcbRemoveListEntry
.Flink
!= NULL
)
1228 RemoveEntryList(&Bcb
->BcbRemoveListEntry
);
1229 Bcb
->BcbRemoveListEntry
.Flink
= NULL
;
1231 Status
= STATUS_SUCCESS
;
1233 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
1240 CcRosInitializeFileCache(PFILE_OBJECT FileObject
,
1241 ULONG CacheSegmentSize
)
1243 * FUNCTION: Initializes a BCB for a file object
1248 Bcb
= FileObject
->SectionObjectPointer
->SharedCacheMap
;
1249 DPRINT("CcRosInitializeFileCache(FileObject 0x%p, Bcb 0x%p, CacheSegmentSize %d)\n",
1250 FileObject
, Bcb
, CacheSegmentSize
);
1252 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
1255 Bcb
= ExAllocateFromNPagedLookasideList(&BcbLookasideList
);
1258 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
1259 return(STATUS_UNSUCCESSFUL
);
1261 memset(Bcb
, 0, sizeof(BCB
));
1262 ObReferenceObjectByPointer(FileObject
,
1266 Bcb
->FileObject
= FileObject
;
1267 Bcb
->CacheSegmentSize
= CacheSegmentSize
;
1268 if (FileObject
->FsContext
)
1270 Bcb
->AllocationSize
=
1271 ((PFSRTL_COMMON_FCB_HEADER
)FileObject
->FsContext
)->AllocationSize
;
1273 ((PFSRTL_COMMON_FCB_HEADER
)FileObject
->FsContext
)->FileSize
;
1275 KeInitializeSpinLock(&Bcb
->BcbLock
);
1276 InitializeListHead(&Bcb
->BcbSegmentListHead
);
1277 FileObject
->SectionObjectPointer
->SharedCacheMap
= Bcb
;
1279 if (FileObject
->PrivateCacheMap
== NULL
)
1281 FileObject
->PrivateCacheMap
= Bcb
;
1284 if (Bcb
->BcbRemoveListEntry
.Flink
!= NULL
)
1286 RemoveEntryList(&Bcb
->BcbRemoveListEntry
);
1287 Bcb
->BcbRemoveListEntry
.Flink
= NULL
;
1289 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
1291 return(STATUS_SUCCESS
);
1297 PFILE_OBJECT STDCALL
1298 CcGetFileObjectFromSectionPtrs(IN PSECTION_OBJECT_POINTERS SectionObjectPointers
)
1301 if (SectionObjectPointers
&& SectionObjectPointers
->SharedCacheMap
)
1303 Bcb
= (PBCB
)SectionObjectPointers
->SharedCacheMap
;
1305 return Bcb
->FileObject
;
1311 CmLazyCloseThreadMain(PVOID Ignored
)
1313 LARGE_INTEGER Timeout
;
1314 PLIST_ENTRY current_entry
;
1316 ULONG RemoveTimeStamp
;
1319 KeQuerySystemTime (&Timeout
);
1323 Timeout
.QuadPart
+= (LONGLONG
)100000000; // 10sec
1324 Status
= KeWaitForSingleObject(&LazyCloseThreadEvent
,
1330 DPRINT("LazyCloseThreadMain %d\n", CcTimeStamp
);
1332 if (!NT_SUCCESS(Status
))
1334 DbgPrint("LazyCloseThread: Wait failed\n");
1338 if (LazyCloseThreadShouldTerminate
)
1340 DbgPrint("LazyCloseThread: Terminating\n");
1344 ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&ViewLock
);
1346 if (CcTimeStamp
>= 30)
1348 RemoveTimeStamp
= CcTimeStamp
- 30; /* 5min = 10sec * 30 */
1349 while (!IsListEmpty(&ClosedListHead
))
1351 current_entry
= ClosedListHead
.Blink
;
1352 current
= CONTAINING_RECORD(current_entry
, BCB
, BcbRemoveListEntry
);
1353 if (current
->TimeStamp
>= RemoveTimeStamp
)
1357 CcRosDeleteFileCache(current
->FileObject
, current
);
1360 ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&ViewLock
);
1372 PHYSICAL_ADDRESS BoundaryAddressMultiple
;
1377 DPRINT("CcInitView()\n");
1379 BoundaryAddressMultiple
.QuadPart
= 0;
1380 CiCacheSegMappingRegionHint
= 0;
1381 CiCacheSegMappingRegionBase
= NULL
;
1383 MmLockAddressSpace(MmGetKernelAddressSpace());
1385 Status
= MmCreateMemoryArea(MmGetKernelAddressSpace(),
1386 MEMORY_AREA_CACHE_SEGMENT
,
1387 &CiCacheSegMappingRegionBase
,
1388 CI_CACHESEG_MAPPING_REGION_SIZE
,
1393 BoundaryAddressMultiple
);
1394 MmUnlockAddressSpace(MmGetKernelAddressSpace());
1395 if (!NT_SUCCESS(Status
))
1400 Buffer
= ExAllocatePool(NonPagedPool
, CI_CACHESEG_MAPPING_REGION_SIZE
/ (PAGE_SIZE
* 8));
1402 RtlInitializeBitMap(&CiCacheSegMappingRegionAllocMap
, Buffer
, CI_CACHESEG_MAPPING_REGION_SIZE
/ PAGE_SIZE
);
1403 RtlClearAllBits(&CiCacheSegMappingRegionAllocMap
);
1405 KeInitializeSpinLock(&CiCacheSegMappingRegionLock
);
1407 InitializeListHead(&CacheSegmentListHead
);
1408 InitializeListHead(&DirtySegmentListHead
);
1409 InitializeListHead(&CacheSegmentLRUListHead
);
1410 InitializeListHead(&ClosedListHead
);
1411 ExInitializeFastMutex(&ViewLock
);
1412 ExInitializeNPagedLookasideList (&iBcbLookasideList
,
1416 sizeof(INTERNAL_BCB
),
1419 ExInitializeNPagedLookasideList (&BcbLookasideList
,
1426 ExInitializeNPagedLookasideList (&CacheSegLookasideList
,
1430 sizeof(CACHE_SEGMENT
),
1434 MmInitializeMemoryConsumer(MC_CACHE
, CcRosTrimCache
);
1436 CcInitCacheZeroPage();
1439 LazyCloseThreadShouldTerminate
= FALSE
;
1440 KeInitializeEvent (&LazyCloseThreadEvent
, SynchronizationEvent
, FALSE
);
1441 Status
= PsCreateSystemThread(&LazyCloseThreadHandle
,
1446 (PKSTART_ROUTINE
)CmLazyCloseThreadMain
,
1448 if (NT_SUCCESS(Status
))
1450 Priority
= LOW_REALTIME_PRIORITY
;
1451 NtSetInformationThread(LazyCloseThreadHandle
,