2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: ntoskrnl/cc/view.c
5 * PURPOSE: Cache manager
7 * PROGRAMMERS: David Welch (welch@mcmail.com)
8 * Pierre Schweitzer (pierre@reactos.org)
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 ******************************************************************/
39 #if defined (ALLOC_PRAGMA)
40 #pragma alloc_text(INIT, CcInitView)
43 /* GLOBALS *******************************************************************/
45 LIST_ENTRY DirtyVacbListHead
;
46 static LIST_ENTRY VacbLruListHead
;
48 KGUARDED_MUTEX ViewLock
;
50 NPAGED_LOOKASIDE_LIST iBcbLookasideList
;
51 static NPAGED_LOOKASIDE_LIST SharedCacheMapLookasideList
;
52 static NPAGED_LOOKASIDE_LIST VacbLookasideList
;
55 * - Amount of pages flushed by lazy writer
56 * - Number of times lazy writer ran
58 ULONG CcLazyWritePages
= 0;
59 ULONG CcLazyWriteIos
= 0;
61 /* Internal vars (MS):
62 * - Threshold above which lazy writer will start action
63 * - Amount of dirty pages
64 * - List for deferred writes
65 * - Spinlock when dealing with the deferred list
66 * - List for "clean" shared cache maps
68 ULONG CcDirtyPageThreshold
= 0;
69 ULONG CcTotalDirtyPages
= 0;
70 LIST_ENTRY CcDeferredWrites
;
71 KSPIN_LOCK CcDeferredWriteSpinLock
;
72 LIST_ENTRY CcCleanSharedCacheMapList
;
74 /* Internal vars (ROS):
75 * - Event to notify lazy writer to shutdown
76 * - Event to inform watchers lazy writer is done for this loop
77 * - Lock for the CcCleanSharedCacheMapList list
79 KEVENT iLazyWriterShutdown
;
80 KEVENT iLazyWriterNotify
;
81 KSPIN_LOCK iSharedCacheMapLock
;
84 static void CcRosVacbIncRefCount_(PROS_VACB vacb
, const char* file
, int line
)
86 ++vacb
->ReferenceCount
;
87 if (vacb
->SharedCacheMap
->Trace
)
89 DbgPrint("(%s:%i) VACB %p ++RefCount=%lu, Dirty %u, PageOut %lu\n",
90 file
, line
, vacb
, vacb
->ReferenceCount
, vacb
->Dirty
, vacb
->PageOut
);
93 static void CcRosVacbDecRefCount_(PROS_VACB vacb
, const char* file
, int line
)
95 --vacb
->ReferenceCount
;
96 if (vacb
->SharedCacheMap
->Trace
)
98 DbgPrint("(%s:%i) VACB %p --RefCount=%lu, Dirty %u, PageOut %lu\n",
99 file
, line
, vacb
, vacb
->ReferenceCount
, vacb
->Dirty
, vacb
->PageOut
);
102 #define CcRosVacbIncRefCount(vacb) CcRosVacbIncRefCount_(vacb,__FILE__,__LINE__)
103 #define CcRosVacbDecRefCount(vacb) CcRosVacbDecRefCount_(vacb,__FILE__,__LINE__)
105 #define CcRosVacbIncRefCount(vacb) (++((vacb)->ReferenceCount))
106 #define CcRosVacbDecRefCount(vacb) (--((vacb)->ReferenceCount))
110 CcRosInternalFreeVacb(PROS_VACB Vacb
);
113 /* FUNCTIONS *****************************************************************/
118 PROS_SHARED_CACHE_MAP SharedCacheMap
,
123 PLIST_ENTRY current_entry
;
129 SharedCacheMap
->Trace
= Trace
;
133 DPRINT1("Enabling Tracing for CacheMap 0x%p:\n", SharedCacheMap
);
135 KeAcquireGuardedMutex(&ViewLock
);
136 KeAcquireSpinLock(&SharedCacheMap
->CacheMapLock
, &oldirql
);
138 current_entry
= SharedCacheMap
->CacheMapVacbListHead
.Flink
;
139 while (current_entry
!= &SharedCacheMap
->CacheMapVacbListHead
)
141 current
= CONTAINING_RECORD(current_entry
, ROS_VACB
, CacheMapVacbListEntry
);
142 current_entry
= current_entry
->Flink
;
144 DPRINT1(" VACB 0x%p enabled, RefCount %lu, Dirty %u, PageOut %lu\n",
145 current
, current
->ReferenceCount
, current
->Dirty
, current
->PageOut
);
147 KeReleaseSpinLock(&SharedCacheMap
->CacheMapLock
, oldirql
);
148 KeReleaseGuardedMutex(&ViewLock
);
152 DPRINT1("Disabling Tracing for CacheMap 0x%p:\n", SharedCacheMap
);
156 UNREFERENCED_PARAMETER(SharedCacheMap
);
157 UNREFERENCED_PARAMETER(Trace
);
169 Status
= CcWriteVirtualAddress(Vacb
);
170 if (NT_SUCCESS(Status
))
172 KeAcquireGuardedMutex(&ViewLock
);
173 KeAcquireSpinLock(&Vacb
->SharedCacheMap
->CacheMapLock
, &oldIrql
);
176 RemoveEntryList(&Vacb
->DirtyVacbListEntry
);
177 CcTotalDirtyPages
-= VACB_MAPPING_GRANULARITY
/ PAGE_SIZE
;
178 CcRosVacbDecRefCount(Vacb
);
180 KeReleaseSpinLock(&Vacb
->SharedCacheMap
->CacheMapLock
, oldIrql
);
181 KeReleaseGuardedMutex(&ViewLock
);
189 CcRosFlushDirtyPages (
193 BOOLEAN CalledFromLazy
)
195 PLIST_ENTRY current_entry
;
199 LARGE_INTEGER ZeroTimeout
;
201 DPRINT("CcRosFlushDirtyPages(Target %lu)\n", Target
);
204 ZeroTimeout
.QuadPart
= 0;
206 KeEnterCriticalRegion();
207 KeAcquireGuardedMutex(&ViewLock
);
209 current_entry
= DirtyVacbListHead
.Flink
;
210 if (current_entry
== &DirtyVacbListHead
)
212 DPRINT("No Dirty pages\n");
215 while ((current_entry
!= &DirtyVacbListHead
) && (Target
> 0))
217 current
= CONTAINING_RECORD(current_entry
,
220 current_entry
= current_entry
->Flink
;
222 CcRosVacbIncRefCount(current
);
224 /* When performing lazy write, don't handle temporary files */
225 if (CalledFromLazy
&&
226 BooleanFlagOn(current
->SharedCacheMap
->FileObject
->Flags
, FO_TEMPORARY_FILE
))
228 CcRosVacbDecRefCount(current
);
232 Locked
= current
->SharedCacheMap
->Callbacks
->AcquireForLazyWrite(
233 current
->SharedCacheMap
->LazyWriteContext
, Wait
);
236 CcRosVacbDecRefCount(current
);
240 Status
= CcRosAcquireVacbLock(current
,
241 Wait
? NULL
: &ZeroTimeout
);
242 if (Status
!= STATUS_SUCCESS
)
244 current
->SharedCacheMap
->Callbacks
->ReleaseFromLazyWrite(
245 current
->SharedCacheMap
->LazyWriteContext
);
246 CcRosVacbDecRefCount(current
);
250 ASSERT(current
->Dirty
);
252 /* One reference is added above */
253 if (current
->ReferenceCount
> 2)
255 CcRosReleaseVacbLock(current
);
256 current
->SharedCacheMap
->Callbacks
->ReleaseFromLazyWrite(
257 current
->SharedCacheMap
->LazyWriteContext
);
258 CcRosVacbDecRefCount(current
);
262 KeReleaseGuardedMutex(&ViewLock
);
264 Status
= CcRosFlushVacb(current
);
266 CcRosReleaseVacbLock(current
);
267 current
->SharedCacheMap
->Callbacks
->ReleaseFromLazyWrite(
268 current
->SharedCacheMap
->LazyWriteContext
);
270 KeAcquireGuardedMutex(&ViewLock
);
271 CcRosVacbDecRefCount(current
);
273 if (!NT_SUCCESS(Status
) && (Status
!= STATUS_END_OF_FILE
) &&
274 (Status
!= STATUS_MEDIA_WRITE_PROTECTED
))
276 DPRINT1("CC: Failed to flush VACB.\n");
282 /* How many pages did we free? */
283 PagesFreed
= VACB_MAPPING_GRANULARITY
/ PAGE_SIZE
;
284 (*Count
) += PagesFreed
;
286 /* Make sure we don't overflow target! */
287 if (Target
< PagesFreed
)
289 /* If we would have, jump to zero directly */
294 Target
-= PagesFreed
;
298 current_entry
= DirtyVacbListHead
.Flink
;
301 KeReleaseGuardedMutex(&ViewLock
);
302 KeLeaveCriticalRegion();
304 DPRINT("CcRosFlushDirtyPages() finished\n");
305 return STATUS_SUCCESS
;
308 /* FIXME: Someday this could somewhat implement write-behind/read-ahead */
311 CciLazyWriter(PVOID Unused
)
313 LARGE_INTEGER OneSecond
;
315 OneSecond
.QuadPart
= (LONGLONG
)-1*1000*1000*10;
320 PLIST_ENTRY ListEntry
;
321 ULONG Target
, Count
= 0;
323 /* One per second or until we have to stop */
324 Status
= KeWaitForSingleObject(&iLazyWriterShutdown
,
330 /* If we succeeed, we've to stop running! */
331 if (Status
== STATUS_SUCCESS
)
336 /* We're not sleeping anymore */
337 KeClearEvent(&iLazyWriterNotify
);
339 /* Our target is one-eighth of the dirty pages */
340 Target
= CcTotalDirtyPages
/ 8;
344 DPRINT("Lazy writer starting (%d)\n", Target
);
345 CcRosFlushDirtyPages(Target
, &Count
, FALSE
, TRUE
);
347 /* And update stats */
348 CcLazyWritePages
+= Count
;
350 DPRINT("Lazy writer done (%d)\n", Count
);
353 /* Inform people waiting on us that we're done */
354 KeSetEvent(&iLazyWriterNotify
, IO_DISK_INCREMENT
, FALSE
);
356 /* Likely not optimal, but let's handle one deferred write now! */
357 ListEntry
= ExInterlockedRemoveHeadList(&CcDeferredWrites
, &CcDeferredWriteSpinLock
);
358 if (ListEntry
!= NULL
)
360 PROS_DEFERRED_WRITE_CONTEXT Context
;
362 /* Extract the context */
363 Context
= CONTAINING_RECORD(ListEntry
, ROS_DEFERRED_WRITE_CONTEXT
, CcDeferredWritesEntry
);
365 /* Can we write now? */
366 if (CcCanIWrite(Context
->FileObject
, Context
->BytesToWrite
, FALSE
, Context
->Retrying
))
368 /* Yes! Do it, and destroy the associated context */
369 Context
->PostRoutine(Context
->Context1
, Context
->Context2
);
370 ExFreePoolWithTag(Context
, 'CcDw');
374 /* Otherwise, requeue it, but in tail, so that it doesn't block others
375 * This is clearly to improve, but given the poor algorithm used now
376 * It's better than nothing!
378 ExInterlockedInsertTailList(&CcDeferredWrites
,
379 &Context
->CcDeferredWritesEntry
,
380 &CcDeferredWriteSpinLock
);
392 * FUNCTION: Try to free some memory from the file cache.
394 * Target - The number of pages to be freed.
395 * Priority - The priority of free (currently unused).
396 * NrFreed - Points to a variable where the number of pages
397 * actually freed is returned.
400 PLIST_ENTRY current_entry
;
407 BOOLEAN FlushedPages
= FALSE
;
409 DPRINT("CcRosTrimCache(Target %lu)\n", Target
);
411 InitializeListHead(&FreeList
);
416 KeAcquireGuardedMutex(&ViewLock
);
418 current_entry
= VacbLruListHead
.Flink
;
419 while (current_entry
!= &VacbLruListHead
)
421 current
= CONTAINING_RECORD(current_entry
,
424 current_entry
= current_entry
->Flink
;
426 KeAcquireSpinLock(¤t
->SharedCacheMap
->CacheMapLock
, &oldIrql
);
428 /* Reference the VACB */
429 CcRosVacbIncRefCount(current
);
431 /* Check if it's mapped and not dirty */
432 if (current
->MappedCount
> 0 && !current
->Dirty
)
434 /* We have to break these locks because Cc sucks */
435 KeReleaseSpinLock(¤t
->SharedCacheMap
->CacheMapLock
, oldIrql
);
436 KeReleaseGuardedMutex(&ViewLock
);
438 /* Page out the VACB */
439 for (i
= 0; i
< VACB_MAPPING_GRANULARITY
/ PAGE_SIZE
; i
++)
441 Page
= (PFN_NUMBER
)(MmGetPhysicalAddress((PUCHAR
)current
->BaseAddress
+ (i
* PAGE_SIZE
)).QuadPart
>> PAGE_SHIFT
);
443 MmPageOutPhysicalAddress(Page
);
446 /* Reacquire the locks */
447 KeAcquireGuardedMutex(&ViewLock
);
448 KeAcquireSpinLock(¤t
->SharedCacheMap
->CacheMapLock
, &oldIrql
);
451 /* Dereference the VACB */
452 CcRosVacbDecRefCount(current
);
454 /* Check if we can free this entry now */
455 if (current
->ReferenceCount
== 0)
457 ASSERT(!current
->Dirty
);
458 ASSERT(!current
->MappedCount
);
460 RemoveEntryList(¤t
->CacheMapVacbListEntry
);
461 RemoveEntryList(¤t
->VacbLruListEntry
);
462 InsertHeadList(&FreeList
, ¤t
->CacheMapVacbListEntry
);
464 /* Calculate how many pages we freed for Mm */
465 PagesFreed
= min(VACB_MAPPING_GRANULARITY
/ PAGE_SIZE
, Target
);
466 Target
-= PagesFreed
;
467 (*NrFreed
) += PagesFreed
;
470 KeReleaseSpinLock(¤t
->SharedCacheMap
->CacheMapLock
, oldIrql
);
473 KeReleaseGuardedMutex(&ViewLock
);
475 /* Try flushing pages if we haven't met our target */
476 if ((Target
> 0) && !FlushedPages
)
478 /* Flush dirty pages to disk */
479 CcRosFlushDirtyPages(Target
, &PagesFreed
, FALSE
, FALSE
);
482 /* We can only swap as many pages as we flushed */
483 if (PagesFreed
< Target
) Target
= PagesFreed
;
485 /* Check if we flushed anything */
488 /* Try again after flushing dirty pages */
489 DPRINT("Flushed %lu dirty cache pages to disk\n", PagesFreed
);
494 while (!IsListEmpty(&FreeList
))
496 current_entry
= RemoveHeadList(&FreeList
);
497 current
= CONTAINING_RECORD(current_entry
,
499 CacheMapVacbListEntry
);
500 CcRosInternalFreeVacb(current
);
503 DPRINT("Evicted %lu cache pages\n", (*NrFreed
));
505 return STATUS_SUCCESS
;
511 PROS_SHARED_CACHE_MAP SharedCacheMap
,
520 ASSERT(SharedCacheMap
);
522 DPRINT("CcRosReleaseVacb(SharedCacheMap 0x%p, Vacb 0x%p, Valid %u)\n",
523 SharedCacheMap
, Vacb
, Valid
);
525 KeAcquireGuardedMutex(&ViewLock
);
526 KeAcquireSpinLock(&SharedCacheMap
->CacheMapLock
, &oldIrql
);
530 WasDirty
= Vacb
->Dirty
;
531 Vacb
->Dirty
= Vacb
->Dirty
|| Dirty
;
533 if (!WasDirty
&& Vacb
->Dirty
)
535 InsertTailList(&DirtyVacbListHead
, &Vacb
->DirtyVacbListEntry
);
536 CcTotalDirtyPages
+= VACB_MAPPING_GRANULARITY
/ PAGE_SIZE
;
543 CcRosVacbDecRefCount(Vacb
);
544 if (Mapped
&& (Vacb
->MappedCount
== 1))
546 CcRosVacbIncRefCount(Vacb
);
548 if (!WasDirty
&& Vacb
->Dirty
)
550 CcRosVacbIncRefCount(Vacb
);
553 KeReleaseSpinLock(&SharedCacheMap
->CacheMapLock
, oldIrql
);
554 KeReleaseGuardedMutex(&ViewLock
);
555 CcRosReleaseVacbLock(Vacb
);
557 return STATUS_SUCCESS
;
560 /* Returns with VACB Lock Held! */
564 PROS_SHARED_CACHE_MAP SharedCacheMap
,
567 PLIST_ENTRY current_entry
;
571 ASSERT(SharedCacheMap
);
573 DPRINT("CcRosLookupVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
574 SharedCacheMap
, FileOffset
);
576 KeAcquireGuardedMutex(&ViewLock
);
577 KeAcquireSpinLock(&SharedCacheMap
->CacheMapLock
, &oldIrql
);
579 current_entry
= SharedCacheMap
->CacheMapVacbListHead
.Flink
;
580 while (current_entry
!= &SharedCacheMap
->CacheMapVacbListHead
)
582 current
= CONTAINING_RECORD(current_entry
,
584 CacheMapVacbListEntry
);
585 if (IsPointInRange(current
->FileOffset
.QuadPart
,
586 VACB_MAPPING_GRANULARITY
,
589 CcRosVacbIncRefCount(current
);
590 KeReleaseSpinLock(&SharedCacheMap
->CacheMapLock
, oldIrql
);
591 KeReleaseGuardedMutex(&ViewLock
);
592 CcRosAcquireVacbLock(current
, NULL
);
595 if (current
->FileOffset
.QuadPart
> FileOffset
)
597 current_entry
= current_entry
->Flink
;
600 KeReleaseSpinLock(&SharedCacheMap
->CacheMapLock
, oldIrql
);
601 KeReleaseGuardedMutex(&ViewLock
);
612 PROS_SHARED_CACHE_MAP SharedCacheMap
;
614 SharedCacheMap
= Vacb
->SharedCacheMap
;
616 KeAcquireGuardedMutex(&ViewLock
);
617 KeAcquireSpinLock(&SharedCacheMap
->CacheMapLock
, &oldIrql
);
621 InsertTailList(&DirtyVacbListHead
, &Vacb
->DirtyVacbListEntry
);
622 CcTotalDirtyPages
+= VACB_MAPPING_GRANULARITY
/ PAGE_SIZE
;
626 CcRosVacbDecRefCount(Vacb
);
629 /* Move to the tail of the LRU list */
630 RemoveEntryList(&Vacb
->VacbLruListEntry
);
631 InsertTailList(&VacbLruListHead
, &Vacb
->VacbLruListEntry
);
635 KeReleaseSpinLock(&SharedCacheMap
->CacheMapLock
, oldIrql
);
636 KeReleaseGuardedMutex(&ViewLock
);
642 PROS_SHARED_CACHE_MAP SharedCacheMap
,
647 ASSERT(SharedCacheMap
);
649 DPRINT("CcRosMarkDirtyVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
650 SharedCacheMap
, FileOffset
);
652 Vacb
= CcRosLookupVacb(SharedCacheMap
, FileOffset
);
655 KeBugCheck(CACHE_MANAGER
);
658 CcRosMarkDirtyVacb(Vacb
);
661 CcRosReleaseVacbLock(Vacb
);
663 return STATUS_SUCCESS
;
669 PROS_SHARED_CACHE_MAP SharedCacheMap
,
677 ASSERT(SharedCacheMap
);
679 DPRINT("CcRosUnmapVacb(SharedCacheMap 0x%p, FileOffset %I64u, NowDirty %u)\n",
680 SharedCacheMap
, FileOffset
, NowDirty
);
682 Vacb
= CcRosLookupVacb(SharedCacheMap
, FileOffset
);
685 return STATUS_UNSUCCESSFUL
;
688 KeAcquireGuardedMutex(&ViewLock
);
689 KeAcquireSpinLock(&SharedCacheMap
->CacheMapLock
, &oldIrql
);
691 WasDirty
= Vacb
->Dirty
;
692 Vacb
->Dirty
= Vacb
->Dirty
|| NowDirty
;
696 if (!WasDirty
&& NowDirty
)
698 InsertTailList(&DirtyVacbListHead
, &Vacb
->DirtyVacbListEntry
);
699 CcTotalDirtyPages
+= VACB_MAPPING_GRANULARITY
/ PAGE_SIZE
;
702 CcRosVacbDecRefCount(Vacb
);
703 if (!WasDirty
&& NowDirty
)
705 CcRosVacbIncRefCount(Vacb
);
707 if (Vacb
->MappedCount
== 0)
709 CcRosVacbDecRefCount(Vacb
);
712 KeReleaseSpinLock(&SharedCacheMap
->CacheMapLock
, oldIrql
);
713 KeReleaseGuardedMutex(&ViewLock
);
714 CcRosReleaseVacbLock(Vacb
);
716 return STATUS_SUCCESS
;
726 ULONG_PTR NumberOfPages
;
728 /* Create a memory area. */
729 MmLockAddressSpace(MmGetKernelAddressSpace());
730 Status
= MmCreateMemoryArea(MmGetKernelAddressSpace(),
731 0, // nothing checks for VACB mareas, so set to 0
733 VACB_MAPPING_GRANULARITY
,
735 (PMEMORY_AREA
*)&Vacb
->MemoryArea
,
738 MmUnlockAddressSpace(MmGetKernelAddressSpace());
739 if (!NT_SUCCESS(Status
))
741 DPRINT1("MmCreateMemoryArea failed with %lx for VACB %p\n", Status
, Vacb
);
745 ASSERT(((ULONG_PTR
)Vacb
->BaseAddress
% PAGE_SIZE
) == 0);
746 ASSERT((ULONG_PTR
)Vacb
->BaseAddress
> (ULONG_PTR
)MmSystemRangeStart
);
748 /* Create a virtual mapping for this memory area */
749 NumberOfPages
= BYTES_TO_PAGES(VACB_MAPPING_GRANULARITY
);
750 for (i
= 0; i
< NumberOfPages
; i
++)
752 PFN_NUMBER PageFrameNumber
;
754 MI_SET_USAGE(MI_USAGE_CACHE
);
755 Status
= MmRequestPageMemoryConsumer(MC_CACHE
, TRUE
, &PageFrameNumber
);
756 if (PageFrameNumber
== 0)
758 DPRINT1("Unable to allocate page\n");
759 KeBugCheck(MEMORY_MANAGEMENT
);
762 Status
= MmCreateVirtualMapping(NULL
,
763 (PVOID
)((ULONG_PTR
)Vacb
->BaseAddress
+ (i
* PAGE_SIZE
)),
767 if (!NT_SUCCESS(Status
))
769 DPRINT1("Unable to create virtual mapping\n");
770 KeBugCheck(MEMORY_MANAGEMENT
);
774 return STATUS_SUCCESS
;
780 PROS_SHARED_CACHE_MAP SharedCacheMap
,
786 PLIST_ENTRY current_entry
;
790 ASSERT(SharedCacheMap
);
792 DPRINT("CcRosCreateVacb()\n");
794 if (FileOffset
>= SharedCacheMap
->SectionSize
.QuadPart
)
797 return STATUS_INVALID_PARAMETER
;
800 current
= ExAllocateFromNPagedLookasideList(&VacbLookasideList
);
801 current
->BaseAddress
= NULL
;
802 current
->Valid
= FALSE
;
803 current
->Dirty
= FALSE
;
804 current
->PageOut
= FALSE
;
805 current
->FileOffset
.QuadPart
= ROUND_DOWN(FileOffset
, VACB_MAPPING_GRANULARITY
);
806 current
->SharedCacheMap
= SharedCacheMap
;
808 if (SharedCacheMap
->Trace
)
810 DPRINT1("CacheMap 0x%p: new VACB: 0x%p\n", SharedCacheMap
, current
);
813 current
->MappedCount
= 0;
814 current
->DirtyVacbListEntry
.Flink
= NULL
;
815 current
->DirtyVacbListEntry
.Blink
= NULL
;
816 current
->ReferenceCount
= 1;
817 current
->PinCount
= 0;
818 KeInitializeMutex(¤t
->Mutex
, 0);
819 CcRosAcquireVacbLock(current
, NULL
);
820 KeAcquireGuardedMutex(&ViewLock
);
823 /* There is window between the call to CcRosLookupVacb
824 * and CcRosCreateVacb. We must check if a VACB for the
825 * file offset exist. If there is a VACB, we release
826 * our newly created VACB and return the existing one.
828 KeAcquireSpinLock(&SharedCacheMap
->CacheMapLock
, &oldIrql
);
829 current_entry
= SharedCacheMap
->CacheMapVacbListHead
.Flink
;
831 while (current_entry
!= &SharedCacheMap
->CacheMapVacbListHead
)
833 current
= CONTAINING_RECORD(current_entry
,
835 CacheMapVacbListEntry
);
836 if (IsPointInRange(current
->FileOffset
.QuadPart
,
837 VACB_MAPPING_GRANULARITY
,
840 CcRosVacbIncRefCount(current
);
841 KeReleaseSpinLock(&SharedCacheMap
->CacheMapLock
, oldIrql
);
843 if (SharedCacheMap
->Trace
)
845 DPRINT1("CacheMap 0x%p: deleting newly created VACB 0x%p ( found existing one 0x%p )\n",
851 CcRosReleaseVacbLock(*Vacb
);
852 KeReleaseGuardedMutex(&ViewLock
);
853 ExFreeToNPagedLookasideList(&VacbLookasideList
, *Vacb
);
855 CcRosAcquireVacbLock(current
, NULL
);
856 return STATUS_SUCCESS
;
858 if (current
->FileOffset
.QuadPart
< FileOffset
)
860 ASSERT(previous
== NULL
||
861 previous
->FileOffset
.QuadPart
< current
->FileOffset
.QuadPart
);
864 if (current
->FileOffset
.QuadPart
> FileOffset
)
866 current_entry
= current_entry
->Flink
;
868 /* There was no existing VACB. */
872 InsertHeadList(&previous
->CacheMapVacbListEntry
, ¤t
->CacheMapVacbListEntry
);
876 InsertHeadList(&SharedCacheMap
->CacheMapVacbListHead
, ¤t
->CacheMapVacbListEntry
);
878 KeReleaseSpinLock(&SharedCacheMap
->CacheMapLock
, oldIrql
);
879 InsertTailList(&VacbLruListHead
, ¤t
->VacbLruListEntry
);
880 KeReleaseGuardedMutex(&ViewLock
);
882 MI_SET_USAGE(MI_USAGE_CACHE
);
884 if ((SharedCacheMap
->FileObject
) && (SharedCacheMap
->FileObject
->FileName
.Buffer
))
888 pos
= wcsrchr(SharedCacheMap
->FileObject
->FileName
.Buffer
, '\\');
891 len
= wcslen(pos
) * sizeof(WCHAR
);
892 snprintf(MI_PFN_CURRENT_PROCESS_NAME
, min(16, len
), "%S", pos
);
896 snprintf(MI_PFN_CURRENT_PROCESS_NAME
, min(16, len
), "%wZ", &SharedCacheMap
->FileObject
->FileName
);
901 Status
= CcRosMapVacb(current
);
902 if (!NT_SUCCESS(Status
))
904 RemoveEntryList(¤t
->CacheMapVacbListEntry
);
905 RemoveEntryList(¤t
->VacbLruListEntry
);
906 CcRosReleaseVacbLock(current
);
907 ExFreeToNPagedLookasideList(&VacbLookasideList
, current
);
916 PROS_SHARED_CACHE_MAP SharedCacheMap
,
918 PLONGLONG BaseOffset
,
926 ASSERT(SharedCacheMap
);
928 DPRINT("CcRosGetVacb()\n");
931 * Look for a VACB already mapping the same data.
933 current
= CcRosLookupVacb(SharedCacheMap
, FileOffset
);
937 * Otherwise create a new VACB.
939 Status
= CcRosCreateVacb(SharedCacheMap
, FileOffset
, ¤t
);
940 if (!NT_SUCCESS(Status
))
946 KeAcquireGuardedMutex(&ViewLock
);
948 /* Move to the tail of the LRU list */
949 RemoveEntryList(¤t
->VacbLruListEntry
);
950 InsertTailList(&VacbLruListHead
, ¤t
->VacbLruListEntry
);
952 KeReleaseGuardedMutex(&ViewLock
);
955 * Return information about the VACB to the caller.
957 *UptoDate
= current
->Valid
;
958 *BaseAddress
= current
->BaseAddress
;
959 DPRINT("*BaseAddress %p\n", *BaseAddress
);
961 *BaseOffset
= current
->FileOffset
.QuadPart
;
962 return STATUS_SUCCESS
;
968 PROS_SHARED_CACHE_MAP SharedCacheMap
,
974 * FUNCTION: Request a page mapping for a shared cache map
979 ASSERT(SharedCacheMap
);
981 if (FileOffset
% VACB_MAPPING_GRANULARITY
!= 0)
983 DPRINT1("Bad fileoffset %I64x should be multiple of %x",
984 FileOffset
, VACB_MAPPING_GRANULARITY
);
985 KeBugCheck(CACHE_MANAGER
);
988 return CcRosGetVacb(SharedCacheMap
,
1000 MEMORY_AREA
* MemoryArea
,
1003 SWAPENTRY SwapEntry
,
1006 ASSERT(SwapEntry
== 0);
1009 ASSERT(MmGetReferenceCountPage(Page
) == 1);
1010 MmReleasePageMemoryConsumer(MC_CACHE
, Page
);
1015 CcRosInternalFreeVacb (
1018 * FUNCTION: Releases a VACB associated with a shared cache map
1021 DPRINT("Freeing VACB 0x%p\n", Vacb
);
1023 if (Vacb
->SharedCacheMap
->Trace
)
1025 DPRINT1("CacheMap 0x%p: deleting VACB: 0x%p\n", Vacb
->SharedCacheMap
, Vacb
);
1029 MmLockAddressSpace(MmGetKernelAddressSpace());
1030 MmFreeMemoryArea(MmGetKernelAddressSpace(),
1034 MmUnlockAddressSpace(MmGetKernelAddressSpace());
1036 ExFreeToNPagedLookasideList(&VacbLookasideList
, Vacb
);
1037 return STATUS_SUCCESS
;
1046 IN PSECTION_OBJECT_POINTERS SectionObjectPointers
,
1047 IN PLARGE_INTEGER FileOffset OPTIONAL
,
1049 OUT PIO_STATUS_BLOCK IoStatus
)
1051 PROS_SHARED_CACHE_MAP SharedCacheMap
;
1052 LARGE_INTEGER Offset
;
1053 LONGLONG RemainingLength
;
1058 CCTRACE(CC_API_DEBUG
, "SectionObjectPointers=%p FileOffset=%p Length=%lu\n",
1059 SectionObjectPointers
, FileOffset
, Length
);
1061 DPRINT("CcFlushCache(SectionObjectPointers 0x%p, FileOffset 0x%p, Length %lu, IoStatus 0x%p)\n",
1062 SectionObjectPointers
, FileOffset
, Length
, IoStatus
);
1064 if (SectionObjectPointers
&& SectionObjectPointers
->SharedCacheMap
)
1066 SharedCacheMap
= SectionObjectPointers
->SharedCacheMap
;
1067 ASSERT(SharedCacheMap
);
1070 Offset
= *FileOffset
;
1071 RemainingLength
= Length
;
1075 Offset
.QuadPart
= 0;
1076 RemainingLength
= SharedCacheMap
->FileSize
.QuadPart
;
1081 IoStatus
->Status
= STATUS_SUCCESS
;
1082 IoStatus
->Information
= 0;
1085 while (RemainingLength
> 0)
1087 current
= CcRosLookupVacb(SharedCacheMap
, Offset
.QuadPart
);
1088 if (current
!= NULL
)
1092 Status
= CcRosFlushVacb(current
);
1093 if (!NT_SUCCESS(Status
) && IoStatus
!= NULL
)
1095 IoStatus
->Status
= Status
;
1099 CcRosReleaseVacbLock(current
);
1101 KeAcquireGuardedMutex(&ViewLock
);
1102 KeAcquireSpinLock(&SharedCacheMap
->CacheMapLock
, &oldIrql
);
1103 CcRosVacbDecRefCount(current
);
1104 KeReleaseSpinLock(&SharedCacheMap
->CacheMapLock
, oldIrql
);
1105 KeReleaseGuardedMutex(&ViewLock
);
1108 Offset
.QuadPart
+= VACB_MAPPING_GRANULARITY
;
1109 RemainingLength
-= min(RemainingLength
, VACB_MAPPING_GRANULARITY
);
1116 IoStatus
->Status
= STATUS_INVALID_PARAMETER
;
1123 CcRosDeleteFileCache (
1124 PFILE_OBJECT FileObject
,
1125 PROS_SHARED_CACHE_MAP SharedCacheMap
)
1127 * FUNCTION: Releases the shared cache map associated with a file object
1130 PLIST_ENTRY current_entry
;
1132 LIST_ENTRY FreeList
;
1135 ASSERT(SharedCacheMap
);
1137 SharedCacheMap
->OpenCount
++;
1138 KeReleaseGuardedMutex(&ViewLock
);
1140 CcFlushCache(FileObject
->SectionObjectPointer
, NULL
, 0, NULL
);
1142 KeAcquireGuardedMutex(&ViewLock
);
1143 SharedCacheMap
->OpenCount
--;
1144 if (SharedCacheMap
->OpenCount
== 0)
1148 FileObject
->SectionObjectPointer
->SharedCacheMap
= NULL
;
1153 InitializeListHead(&FreeList
);
1154 KeAcquireSpinLock(&SharedCacheMap
->CacheMapLock
, &oldIrql
);
1155 while (!IsListEmpty(&SharedCacheMap
->CacheMapVacbListHead
))
1157 current_entry
= RemoveTailList(&SharedCacheMap
->CacheMapVacbListHead
);
1158 current
= CONTAINING_RECORD(current_entry
, ROS_VACB
, CacheMapVacbListEntry
);
1159 RemoveEntryList(¤t
->VacbLruListEntry
);
1162 RemoveEntryList(¤t
->DirtyVacbListEntry
);
1163 CcTotalDirtyPages
-= VACB_MAPPING_GRANULARITY
/ PAGE_SIZE
;
1164 DPRINT1("Freeing dirty VACB\n");
1166 InsertHeadList(&FreeList
, ¤t
->CacheMapVacbListEntry
);
1169 SharedCacheMap
->Trace
= FALSE
;
1171 KeReleaseSpinLock(&SharedCacheMap
->CacheMapLock
, oldIrql
);
1173 KeReleaseGuardedMutex(&ViewLock
);
1174 ObDereferenceObject(SharedCacheMap
->FileObject
);
1176 while (!IsListEmpty(&FreeList
))
1178 current_entry
= RemoveTailList(&FreeList
);
1179 current
= CONTAINING_RECORD(current_entry
, ROS_VACB
, CacheMapVacbListEntry
);
1180 CcRosInternalFreeVacb(current
);
1183 KeAcquireSpinLock(&iSharedCacheMapLock
, &OldIrql
);
1184 RemoveEntryList(&SharedCacheMap
->SharedCacheMapLinks
);
1185 KeReleaseSpinLock(&iSharedCacheMapLock
, OldIrql
);
1187 ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList
, SharedCacheMap
);
1188 KeAcquireGuardedMutex(&ViewLock
);
1190 return STATUS_SUCCESS
;
1195 CcRosReferenceCache (
1196 PFILE_OBJECT FileObject
)
1198 PROS_SHARED_CACHE_MAP SharedCacheMap
;
1199 KeAcquireGuardedMutex(&ViewLock
);
1200 SharedCacheMap
= FileObject
->SectionObjectPointer
->SharedCacheMap
;
1201 ASSERT(SharedCacheMap
);
1202 ASSERT(SharedCacheMap
->OpenCount
!= 0);
1203 SharedCacheMap
->OpenCount
++;
1204 KeReleaseGuardedMutex(&ViewLock
);
1209 CcRosRemoveIfClosed (
1210 PSECTION_OBJECT_POINTERS SectionObjectPointer
)
1212 PROS_SHARED_CACHE_MAP SharedCacheMap
;
1213 DPRINT("CcRosRemoveIfClosed()\n");
1214 KeAcquireGuardedMutex(&ViewLock
);
1215 SharedCacheMap
= SectionObjectPointer
->SharedCacheMap
;
1216 if (SharedCacheMap
&& SharedCacheMap
->OpenCount
== 0)
1218 CcRosDeleteFileCache(SharedCacheMap
->FileObject
, SharedCacheMap
);
1220 KeReleaseGuardedMutex(&ViewLock
);
1226 CcRosDereferenceCache (
1227 PFILE_OBJECT FileObject
)
1229 PROS_SHARED_CACHE_MAP SharedCacheMap
;
1230 KeAcquireGuardedMutex(&ViewLock
);
1231 SharedCacheMap
= FileObject
->SectionObjectPointer
->SharedCacheMap
;
1232 ASSERT(SharedCacheMap
);
1233 if (SharedCacheMap
->OpenCount
> 0)
1235 SharedCacheMap
->OpenCount
--;
1236 if (SharedCacheMap
->OpenCount
== 0)
1238 MmFreeSectionSegments(SharedCacheMap
->FileObject
);
1239 CcRosDeleteFileCache(FileObject
, SharedCacheMap
);
1242 KeReleaseGuardedMutex(&ViewLock
);
1247 CcRosReleaseFileCache (
1248 PFILE_OBJECT FileObject
)
1250 * FUNCTION: Called by the file system when a handle to a file object
1254 PROS_SHARED_CACHE_MAP SharedCacheMap
;
1256 KeAcquireGuardedMutex(&ViewLock
);
1258 if (FileObject
->SectionObjectPointer
->SharedCacheMap
!= NULL
)
1260 SharedCacheMap
= FileObject
->SectionObjectPointer
->SharedCacheMap
;
1261 if (FileObject
->PrivateCacheMap
!= NULL
)
1263 FileObject
->PrivateCacheMap
= NULL
;
1264 if (SharedCacheMap
->OpenCount
> 0)
1266 SharedCacheMap
->OpenCount
--;
1267 if (SharedCacheMap
->OpenCount
== 0)
1269 MmFreeSectionSegments(SharedCacheMap
->FileObject
);
1270 CcRosDeleteFileCache(FileObject
, SharedCacheMap
);
1275 KeReleaseGuardedMutex(&ViewLock
);
1276 return STATUS_SUCCESS
;
1281 CcTryToInitializeFileCache (
1282 PFILE_OBJECT FileObject
)
1284 PROS_SHARED_CACHE_MAP SharedCacheMap
;
1287 KeAcquireGuardedMutex(&ViewLock
);
1289 ASSERT(FileObject
->SectionObjectPointer
);
1290 SharedCacheMap
= FileObject
->SectionObjectPointer
->SharedCacheMap
;
1291 if (SharedCacheMap
== NULL
)
1293 Status
= STATUS_UNSUCCESSFUL
;
1297 if (FileObject
->PrivateCacheMap
== NULL
)
1299 FileObject
->PrivateCacheMap
= SharedCacheMap
;
1300 SharedCacheMap
->OpenCount
++;
1302 Status
= STATUS_SUCCESS
;
1304 KeReleaseGuardedMutex(&ViewLock
);
1312 CcRosInitializeFileCache (
1313 PFILE_OBJECT FileObject
,
1314 PCC_FILE_SIZES FileSizes
,
1316 PCACHE_MANAGER_CALLBACKS CallBacks
,
1317 PVOID LazyWriterContext
)
1319 * FUNCTION: Initializes a shared cache map for a file object
1322 PROS_SHARED_CACHE_MAP SharedCacheMap
;
1324 SharedCacheMap
= FileObject
->SectionObjectPointer
->SharedCacheMap
;
1325 DPRINT("CcRosInitializeFileCache(FileObject 0x%p, SharedCacheMap 0x%p)\n",
1326 FileObject
, SharedCacheMap
);
1328 KeAcquireGuardedMutex(&ViewLock
);
1329 if (SharedCacheMap
== NULL
)
1333 SharedCacheMap
= ExAllocateFromNPagedLookasideList(&SharedCacheMapLookasideList
);
1334 if (SharedCacheMap
== NULL
)
1336 KeReleaseGuardedMutex(&ViewLock
);
1337 return STATUS_INSUFFICIENT_RESOURCES
;
1339 RtlZeroMemory(SharedCacheMap
, sizeof(*SharedCacheMap
));
1340 ObReferenceObjectByPointer(FileObject
,
1344 SharedCacheMap
->FileObject
= FileObject
;
1345 SharedCacheMap
->Callbacks
= CallBacks
;
1346 SharedCacheMap
->LazyWriteContext
= LazyWriterContext
;
1347 SharedCacheMap
->SectionSize
= FileSizes
->AllocationSize
;
1348 SharedCacheMap
->FileSize
= FileSizes
->FileSize
;
1349 SharedCacheMap
->PinAccess
= PinAccess
;
1350 SharedCacheMap
->DirtyPageThreshold
= 0;
1351 KeInitializeSpinLock(&SharedCacheMap
->CacheMapLock
);
1352 InitializeListHead(&SharedCacheMap
->CacheMapVacbListHead
);
1353 FileObject
->SectionObjectPointer
->SharedCacheMap
= SharedCacheMap
;
1355 KeAcquireSpinLock(&iSharedCacheMapLock
, &OldIrql
);
1356 InsertTailList(&CcCleanSharedCacheMapList
, &SharedCacheMap
->SharedCacheMapLinks
);
1357 KeReleaseSpinLock(&iSharedCacheMapLock
, OldIrql
);
1359 if (FileObject
->PrivateCacheMap
== NULL
)
1361 FileObject
->PrivateCacheMap
= SharedCacheMap
;
1362 SharedCacheMap
->OpenCount
++;
1364 KeReleaseGuardedMutex(&ViewLock
);
1366 return STATUS_SUCCESS
;
1374 CcGetFileObjectFromSectionPtrs (
1375 IN PSECTION_OBJECT_POINTERS SectionObjectPointers
)
1377 PROS_SHARED_CACHE_MAP SharedCacheMap
;
1379 CCTRACE(CC_API_DEBUG
, "SectionObjectPointers=%p\n", SectionObjectPointers
);
1381 if (SectionObjectPointers
&& SectionObjectPointers
->SharedCacheMap
)
1383 SharedCacheMap
= SectionObjectPointers
->SharedCacheMap
;
1384 ASSERT(SharedCacheMap
);
1385 return SharedCacheMap
->FileObject
;
1392 CcShutdownLazyWriter (
1395 /* Simply set the event, lazy writer will stop when it's done */
1396 KeSetEvent(&iLazyWriterShutdown
, IO_DISK_INCREMENT
, FALSE
);
1408 OBJECT_ATTRIBUTES ObjectAttributes
;
1410 DPRINT("CcInitView()\n");
1412 InitializeListHead(&DirtyVacbListHead
);
1413 InitializeListHead(&VacbLruListHead
);
1414 InitializeListHead(&CcDeferredWrites
);
1415 InitializeListHead(&CcCleanSharedCacheMapList
);
1416 KeInitializeSpinLock(&CcDeferredWriteSpinLock
);
1417 KeInitializeSpinLock(&iSharedCacheMapLock
);
1418 KeInitializeGuardedMutex(&ViewLock
);
1419 ExInitializeNPagedLookasideList(&iBcbLookasideList
,
1423 sizeof(INTERNAL_BCB
),
1426 ExInitializeNPagedLookasideList(&SharedCacheMapLookasideList
,
1430 sizeof(ROS_SHARED_CACHE_MAP
),
1431 TAG_SHARED_CACHE_MAP
,
1433 ExInitializeNPagedLookasideList(&VacbLookasideList
,
1441 MmInitializeMemoryConsumer(MC_CACHE
, CcRosTrimCache
);
1443 /* Initialize lazy writer events */
1444 KeInitializeEvent(&iLazyWriterShutdown
, SynchronizationEvent
, FALSE
);
1445 KeInitializeEvent(&iLazyWriterNotify
, NotificationEvent
, FALSE
);
1447 /* Define lazy writer threshold, depending on system type */
1448 switch (MmQuerySystemSize())
1451 CcDirtyPageThreshold
= MmNumberOfPhysicalPages
/ 8;
1454 case MmMediumSystem
:
1455 CcDirtyPageThreshold
= MmNumberOfPhysicalPages
/ 4;
1459 CcDirtyPageThreshold
= MmNumberOfPhysicalPages
/ 8 + MmNumberOfPhysicalPages
/ 4;
1463 /* Start the lazy writer thread */
1464 InitializeObjectAttributes(&ObjectAttributes
,
1469 Status
= PsCreateSystemThread(&LazyWriter
,
1476 if (!NT_SUCCESS(Status
))
1482 Status
= NtSetInformationThread(LazyWriter
,
1486 ASSERT(NT_SUCCESS(Status
));
1488 /* Handle is not needed */
1489 ObCloseHandle(LazyWriter
, KernelMode
);
1491 CcInitCacheZeroPage();
1496 #if DBG && defined(KDBG)
1498 ExpKdbgExtFileCache(ULONG Argc
, PCHAR Argv
[])
1500 PLIST_ENTRY ListEntry
;
1501 UNICODE_STRING NoName
= RTL_CONSTANT_STRING(L
"No name for File");
1503 KdbpPrint(" Usage Summary (in kb)\n");
1504 KdbpPrint("Shared\t\tValid\tDirty\tName\n");
1505 /* No need to lock the spin lock here, we're in DBG */
1506 for (ListEntry
= CcCleanSharedCacheMapList
.Flink
;
1507 ListEntry
!= &CcCleanSharedCacheMapList
;
1508 ListEntry
= ListEntry
->Flink
)
1511 ULONG Valid
= 0, Dirty
= 0;
1512 PROS_SHARED_CACHE_MAP SharedCacheMap
;
1513 PUNICODE_STRING FileName
;
1515 SharedCacheMap
= CONTAINING_RECORD(ListEntry
, ROS_SHARED_CACHE_MAP
, SharedCacheMapLinks
);
1517 /* First, count for all the associated VACB */
1518 for (Vacbs
= SharedCacheMap
->CacheMapVacbListHead
.Flink
;
1519 Vacbs
!= &SharedCacheMap
->CacheMapVacbListHead
;
1520 Vacbs
= Vacbs
->Flink
)
1524 Vacb
= CONTAINING_RECORD(Vacbs
, ROS_VACB
, CacheMapVacbListEntry
);
1527 Dirty
+= VACB_MAPPING_GRANULARITY
/ 1024;
1531 Valid
+= VACB_MAPPING_GRANULARITY
/ 1024;
1536 if (SharedCacheMap
->FileObject
!= NULL
&&
1537 SharedCacheMap
->FileObject
->FileName
.Length
!= 0)
1539 FileName
= &SharedCacheMap
->FileObject
->FileName
;
1547 KdbpPrint("%p\t%d\t%d\t%wZ\n", SharedCacheMap
, Valid
, Dirty
, FileName
);