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 Vacb
->SharedCacheMap
->DirtyPages
-= VACB_MAPPING_GRANULARITY
/ PAGE_SIZE
;
179 CcRosVacbDecRefCount(Vacb
);
181 KeReleaseSpinLock(&Vacb
->SharedCacheMap
->CacheMapLock
, oldIrql
);
182 KeReleaseGuardedMutex(&ViewLock
);
190 CcRosFlushDirtyPages (
194 BOOLEAN CalledFromLazy
)
196 PLIST_ENTRY current_entry
;
200 LARGE_INTEGER ZeroTimeout
;
202 DPRINT("CcRosFlushDirtyPages(Target %lu)\n", Target
);
205 ZeroTimeout
.QuadPart
= 0;
207 KeEnterCriticalRegion();
208 KeAcquireGuardedMutex(&ViewLock
);
210 current_entry
= DirtyVacbListHead
.Flink
;
211 if (current_entry
== &DirtyVacbListHead
)
213 DPRINT("No Dirty pages\n");
216 while ((current_entry
!= &DirtyVacbListHead
) && (Target
> 0))
218 current
= CONTAINING_RECORD(current_entry
,
221 current_entry
= current_entry
->Flink
;
223 CcRosVacbIncRefCount(current
);
225 /* When performing lazy write, don't handle temporary files */
226 if (CalledFromLazy
&&
227 BooleanFlagOn(current
->SharedCacheMap
->FileObject
->Flags
, FO_TEMPORARY_FILE
))
229 CcRosVacbDecRefCount(current
);
233 Locked
= current
->SharedCacheMap
->Callbacks
->AcquireForLazyWrite(
234 current
->SharedCacheMap
->LazyWriteContext
, Wait
);
237 CcRosVacbDecRefCount(current
);
241 Status
= CcRosAcquireVacbLock(current
,
242 Wait
? NULL
: &ZeroTimeout
);
243 if (Status
!= STATUS_SUCCESS
)
245 current
->SharedCacheMap
->Callbacks
->ReleaseFromLazyWrite(
246 current
->SharedCacheMap
->LazyWriteContext
);
247 CcRosVacbDecRefCount(current
);
251 ASSERT(current
->Dirty
);
253 /* One reference is added above */
254 if ((current
->ReferenceCount
> 2 && current
->PinCount
== 0) ||
255 (current
->ReferenceCount
> 3 && current
->PinCount
> 1))
257 CcRosReleaseVacbLock(current
);
258 current
->SharedCacheMap
->Callbacks
->ReleaseFromLazyWrite(
259 current
->SharedCacheMap
->LazyWriteContext
);
260 CcRosVacbDecRefCount(current
);
264 KeReleaseGuardedMutex(&ViewLock
);
266 Status
= CcRosFlushVacb(current
);
268 CcRosReleaseVacbLock(current
);
269 current
->SharedCacheMap
->Callbacks
->ReleaseFromLazyWrite(
270 current
->SharedCacheMap
->LazyWriteContext
);
272 KeAcquireGuardedMutex(&ViewLock
);
273 CcRosVacbDecRefCount(current
);
275 if (!NT_SUCCESS(Status
) && (Status
!= STATUS_END_OF_FILE
) &&
276 (Status
!= STATUS_MEDIA_WRITE_PROTECTED
))
278 DPRINT1("CC: Failed to flush VACB.\n");
284 /* How many pages did we free? */
285 PagesFreed
= VACB_MAPPING_GRANULARITY
/ PAGE_SIZE
;
286 (*Count
) += PagesFreed
;
288 /* Make sure we don't overflow target! */
289 if (Target
< PagesFreed
)
291 /* If we would have, jump to zero directly */
296 Target
-= PagesFreed
;
300 current_entry
= DirtyVacbListHead
.Flink
;
303 KeReleaseGuardedMutex(&ViewLock
);
304 KeLeaveCriticalRegion();
306 DPRINT("CcRosFlushDirtyPages() finished\n");
307 return STATUS_SUCCESS
;
310 /* FIXME: Someday this could somewhat implement write-behind/read-ahead */
313 CciLazyWriter(PVOID Unused
)
315 LARGE_INTEGER OneSecond
;
317 OneSecond
.QuadPart
= (LONGLONG
)-1*1000*1000*10;
322 PLIST_ENTRY ListEntry
;
323 ULONG Target
, Count
= 0;
325 /* One per second or until we have to stop */
326 Status
= KeWaitForSingleObject(&iLazyWriterShutdown
,
332 /* If we succeeed, we've to stop running! */
333 if (Status
== STATUS_SUCCESS
)
338 /* We're not sleeping anymore */
339 KeClearEvent(&iLazyWriterNotify
);
341 /* Our target is one-eighth of the dirty pages */
342 Target
= CcTotalDirtyPages
/ 8;
346 DPRINT("Lazy writer starting (%d)\n", Target
);
347 CcRosFlushDirtyPages(Target
, &Count
, FALSE
, TRUE
);
349 /* And update stats */
350 CcLazyWritePages
+= Count
;
352 DPRINT("Lazy writer done (%d)\n", Count
);
355 /* Inform people waiting on us that we're done */
356 KeSetEvent(&iLazyWriterNotify
, IO_DISK_INCREMENT
, FALSE
);
358 /* Likely not optimal, but let's handle one deferred write now! */
359 ListEntry
= ExInterlockedRemoveHeadList(&CcDeferredWrites
, &CcDeferredWriteSpinLock
);
360 if (ListEntry
!= NULL
)
362 PROS_DEFERRED_WRITE_CONTEXT Context
;
364 /* Extract the context */
365 Context
= CONTAINING_RECORD(ListEntry
, ROS_DEFERRED_WRITE_CONTEXT
, CcDeferredWritesEntry
);
367 /* Can we write now? */
368 if (CcCanIWrite(Context
->FileObject
, Context
->BytesToWrite
, FALSE
, Context
->Retrying
))
370 /* Yes! Do it, and destroy the associated context */
371 Context
->PostRoutine(Context
->Context1
, Context
->Context2
);
372 ExFreePoolWithTag(Context
, 'CcDw');
376 /* Otherwise, requeue it, but in tail, so that it doesn't block others
377 * This is clearly to improve, but given the poor algorithm used now
378 * It's better than nothing!
380 ExInterlockedInsertTailList(&CcDeferredWrites
,
381 &Context
->CcDeferredWritesEntry
,
382 &CcDeferredWriteSpinLock
);
394 * FUNCTION: Try to free some memory from the file cache.
396 * Target - The number of pages to be freed.
397 * Priority - The priority of free (currently unused).
398 * NrFreed - Points to a variable where the number of pages
399 * actually freed is returned.
402 PLIST_ENTRY current_entry
;
409 BOOLEAN FlushedPages
= FALSE
;
411 DPRINT("CcRosTrimCache(Target %lu)\n", Target
);
413 InitializeListHead(&FreeList
);
418 KeAcquireGuardedMutex(&ViewLock
);
420 current_entry
= VacbLruListHead
.Flink
;
421 while (current_entry
!= &VacbLruListHead
)
423 current
= CONTAINING_RECORD(current_entry
,
426 current_entry
= current_entry
->Flink
;
428 KeAcquireSpinLock(¤t
->SharedCacheMap
->CacheMapLock
, &oldIrql
);
430 /* Reference the VACB */
431 CcRosVacbIncRefCount(current
);
433 /* Check if it's mapped and not dirty */
434 if (current
->MappedCount
> 0 && !current
->Dirty
)
436 /* We have to break these locks because Cc sucks */
437 KeReleaseSpinLock(¤t
->SharedCacheMap
->CacheMapLock
, oldIrql
);
438 KeReleaseGuardedMutex(&ViewLock
);
440 /* Page out the VACB */
441 for (i
= 0; i
< VACB_MAPPING_GRANULARITY
/ PAGE_SIZE
; i
++)
443 Page
= (PFN_NUMBER
)(MmGetPhysicalAddress((PUCHAR
)current
->BaseAddress
+ (i
* PAGE_SIZE
)).QuadPart
>> PAGE_SHIFT
);
445 MmPageOutPhysicalAddress(Page
);
448 /* Reacquire the locks */
449 KeAcquireGuardedMutex(&ViewLock
);
450 KeAcquireSpinLock(¤t
->SharedCacheMap
->CacheMapLock
, &oldIrql
);
453 /* Dereference the VACB */
454 CcRosVacbDecRefCount(current
);
456 /* Check if we can free this entry now */
457 if (current
->ReferenceCount
== 0)
459 ASSERT(!current
->Dirty
);
460 ASSERT(!current
->MappedCount
);
462 RemoveEntryList(¤t
->CacheMapVacbListEntry
);
463 RemoveEntryList(¤t
->VacbLruListEntry
);
464 InsertHeadList(&FreeList
, ¤t
->CacheMapVacbListEntry
);
466 /* Calculate how many pages we freed for Mm */
467 PagesFreed
= min(VACB_MAPPING_GRANULARITY
/ PAGE_SIZE
, Target
);
468 Target
-= PagesFreed
;
469 (*NrFreed
) += PagesFreed
;
472 KeReleaseSpinLock(¤t
->SharedCacheMap
->CacheMapLock
, oldIrql
);
475 KeReleaseGuardedMutex(&ViewLock
);
477 /* Try flushing pages if we haven't met our target */
478 if ((Target
> 0) && !FlushedPages
)
480 /* Flush dirty pages to disk */
481 CcRosFlushDirtyPages(Target
, &PagesFreed
, FALSE
, FALSE
);
484 /* We can only swap as many pages as we flushed */
485 if (PagesFreed
< Target
) Target
= PagesFreed
;
487 /* Check if we flushed anything */
490 /* Try again after flushing dirty pages */
491 DPRINT("Flushed %lu dirty cache pages to disk\n", PagesFreed
);
496 while (!IsListEmpty(&FreeList
))
498 current_entry
= RemoveHeadList(&FreeList
);
499 current
= CONTAINING_RECORD(current_entry
,
501 CacheMapVacbListEntry
);
502 CcRosInternalFreeVacb(current
);
505 DPRINT("Evicted %lu cache pages\n", (*NrFreed
));
507 return STATUS_SUCCESS
;
513 PROS_SHARED_CACHE_MAP SharedCacheMap
,
521 ASSERT(SharedCacheMap
);
523 DPRINT("CcRosReleaseVacb(SharedCacheMap 0x%p, Vacb 0x%p, Valid %u)\n",
524 SharedCacheMap
, Vacb
, Valid
);
531 if (!Vacb
->Dirty
&& Dirty
)
533 CcRosMarkDirtyVacb(Vacb
);
545 CcRosVacbDecRefCount(Vacb
);
546 if (Mapped
&& (Vacb
->MappedCount
== 1))
548 CcRosVacbIncRefCount(Vacb
);
550 if (!WasDirty
&& Vacb
->Dirty
)
552 CcRosVacbIncRefCount(Vacb
);
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
;
623 Vacb
->SharedCacheMap
->DirtyPages
+= VACB_MAPPING_GRANULARITY
/ PAGE_SIZE
;
627 CcRosVacbDecRefCount(Vacb
);
630 /* Move to the tail of the LRU list */
631 RemoveEntryList(&Vacb
->VacbLruListEntry
);
632 InsertTailList(&VacbLruListHead
, &Vacb
->VacbLruListEntry
);
636 KeReleaseSpinLock(&SharedCacheMap
->CacheMapLock
, oldIrql
);
637 KeReleaseGuardedMutex(&ViewLock
);
643 PROS_SHARED_CACHE_MAP SharedCacheMap
,
648 ASSERT(SharedCacheMap
);
650 DPRINT("CcRosMarkDirtyVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
651 SharedCacheMap
, FileOffset
);
653 Vacb
= CcRosLookupVacb(SharedCacheMap
, FileOffset
);
656 KeBugCheck(CACHE_MANAGER
);
659 CcRosMarkDirtyVacb(Vacb
);
662 CcRosReleaseVacbLock(Vacb
);
664 return STATUS_SUCCESS
;
670 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
;
691 if (!Vacb
->Dirty
&& NowDirty
)
693 CcRosMarkDirtyVacb(Vacb
);
703 CcRosVacbDecRefCount(Vacb
);
704 if (!WasDirty
&& NowDirty
)
706 CcRosVacbIncRefCount(Vacb
);
708 if (Vacb
->MappedCount
== 0)
710 CcRosVacbDecRefCount(Vacb
);
713 CcRosReleaseVacbLock(Vacb
);
715 return STATUS_SUCCESS
;
725 ULONG_PTR NumberOfPages
;
727 /* Create a memory area. */
728 MmLockAddressSpace(MmGetKernelAddressSpace());
729 Status
= MmCreateMemoryArea(MmGetKernelAddressSpace(),
730 0, // nothing checks for VACB mareas, so set to 0
732 VACB_MAPPING_GRANULARITY
,
734 (PMEMORY_AREA
*)&Vacb
->MemoryArea
,
737 MmUnlockAddressSpace(MmGetKernelAddressSpace());
738 if (!NT_SUCCESS(Status
))
740 DPRINT1("MmCreateMemoryArea failed with %lx for VACB %p\n", Status
, Vacb
);
744 ASSERT(((ULONG_PTR
)Vacb
->BaseAddress
% PAGE_SIZE
) == 0);
745 ASSERT((ULONG_PTR
)Vacb
->BaseAddress
> (ULONG_PTR
)MmSystemRangeStart
);
747 /* Create a virtual mapping for this memory area */
748 NumberOfPages
= BYTES_TO_PAGES(VACB_MAPPING_GRANULARITY
);
749 for (i
= 0; i
< NumberOfPages
; i
++)
751 PFN_NUMBER PageFrameNumber
;
753 MI_SET_USAGE(MI_USAGE_CACHE
);
754 Status
= MmRequestPageMemoryConsumer(MC_CACHE
, TRUE
, &PageFrameNumber
);
755 if (PageFrameNumber
== 0)
757 DPRINT1("Unable to allocate page\n");
758 KeBugCheck(MEMORY_MANAGEMENT
);
761 Status
= MmCreateVirtualMapping(NULL
,
762 (PVOID
)((ULONG_PTR
)Vacb
->BaseAddress
+ (i
* PAGE_SIZE
)),
766 if (!NT_SUCCESS(Status
))
768 DPRINT1("Unable to create virtual mapping\n");
769 KeBugCheck(MEMORY_MANAGEMENT
);
773 return STATUS_SUCCESS
;
779 PROS_SHARED_CACHE_MAP SharedCacheMap
,
785 PLIST_ENTRY current_entry
;
789 ASSERT(SharedCacheMap
);
791 DPRINT("CcRosCreateVacb()\n");
793 if (FileOffset
>= SharedCacheMap
->SectionSize
.QuadPart
)
796 return STATUS_INVALID_PARAMETER
;
799 current
= ExAllocateFromNPagedLookasideList(&VacbLookasideList
);
800 current
->BaseAddress
= NULL
;
801 current
->Valid
= FALSE
;
802 current
->Dirty
= FALSE
;
803 current
->PageOut
= FALSE
;
804 current
->FileOffset
.QuadPart
= ROUND_DOWN(FileOffset
, VACB_MAPPING_GRANULARITY
);
805 current
->SharedCacheMap
= SharedCacheMap
;
807 if (SharedCacheMap
->Trace
)
809 DPRINT1("CacheMap 0x%p: new VACB: 0x%p\n", SharedCacheMap
, current
);
812 current
->MappedCount
= 0;
813 current
->DirtyVacbListEntry
.Flink
= NULL
;
814 current
->DirtyVacbListEntry
.Blink
= NULL
;
815 current
->ReferenceCount
= 1;
816 current
->PinCount
= 0;
817 KeInitializeMutex(¤t
->Mutex
, 0);
818 CcRosAcquireVacbLock(current
, NULL
);
819 KeAcquireGuardedMutex(&ViewLock
);
822 /* There is window between the call to CcRosLookupVacb
823 * and CcRosCreateVacb. We must check if a VACB for the
824 * file offset exist. If there is a VACB, we release
825 * our newly created VACB and return the existing one.
827 KeAcquireSpinLock(&SharedCacheMap
->CacheMapLock
, &oldIrql
);
828 current_entry
= SharedCacheMap
->CacheMapVacbListHead
.Flink
;
830 while (current_entry
!= &SharedCacheMap
->CacheMapVacbListHead
)
832 current
= CONTAINING_RECORD(current_entry
,
834 CacheMapVacbListEntry
);
835 if (IsPointInRange(current
->FileOffset
.QuadPart
,
836 VACB_MAPPING_GRANULARITY
,
839 CcRosVacbIncRefCount(current
);
840 KeReleaseSpinLock(&SharedCacheMap
->CacheMapLock
, oldIrql
);
842 if (SharedCacheMap
->Trace
)
844 DPRINT1("CacheMap 0x%p: deleting newly created VACB 0x%p ( found existing one 0x%p )\n",
850 CcRosReleaseVacbLock(*Vacb
);
851 KeReleaseGuardedMutex(&ViewLock
);
852 ExFreeToNPagedLookasideList(&VacbLookasideList
, *Vacb
);
854 CcRosAcquireVacbLock(current
, NULL
);
855 return STATUS_SUCCESS
;
857 if (current
->FileOffset
.QuadPart
< FileOffset
)
859 ASSERT(previous
== NULL
||
860 previous
->FileOffset
.QuadPart
< current
->FileOffset
.QuadPart
);
863 if (current
->FileOffset
.QuadPart
> FileOffset
)
865 current_entry
= current_entry
->Flink
;
867 /* There was no existing VACB. */
871 InsertHeadList(&previous
->CacheMapVacbListEntry
, ¤t
->CacheMapVacbListEntry
);
875 InsertHeadList(&SharedCacheMap
->CacheMapVacbListHead
, ¤t
->CacheMapVacbListEntry
);
877 KeReleaseSpinLock(&SharedCacheMap
->CacheMapLock
, oldIrql
);
878 InsertTailList(&VacbLruListHead
, ¤t
->VacbLruListEntry
);
879 KeReleaseGuardedMutex(&ViewLock
);
881 MI_SET_USAGE(MI_USAGE_CACHE
);
883 if ((SharedCacheMap
->FileObject
) && (SharedCacheMap
->FileObject
->FileName
.Buffer
))
887 pos
= wcsrchr(SharedCacheMap
->FileObject
->FileName
.Buffer
, '\\');
890 len
= wcslen(pos
) * sizeof(WCHAR
);
891 snprintf(MI_PFN_CURRENT_PROCESS_NAME
, min(16, len
), "%S", pos
);
895 snprintf(MI_PFN_CURRENT_PROCESS_NAME
, min(16, len
), "%wZ", &SharedCacheMap
->FileObject
->FileName
);
900 Status
= CcRosMapVacb(current
);
901 if (!NT_SUCCESS(Status
))
903 RemoveEntryList(¤t
->CacheMapVacbListEntry
);
904 RemoveEntryList(¤t
->VacbLruListEntry
);
905 CcRosReleaseVacbLock(current
);
906 ExFreeToNPagedLookasideList(&VacbLookasideList
, current
);
915 PROS_SHARED_CACHE_MAP SharedCacheMap
,
917 PLONGLONG BaseOffset
,
925 ASSERT(SharedCacheMap
);
927 DPRINT("CcRosGetVacb()\n");
930 * Look for a VACB already mapping the same data.
932 current
= CcRosLookupVacb(SharedCacheMap
, FileOffset
);
936 * Otherwise create a new VACB.
938 Status
= CcRosCreateVacb(SharedCacheMap
, FileOffset
, ¤t
);
939 if (!NT_SUCCESS(Status
))
945 KeAcquireGuardedMutex(&ViewLock
);
947 /* Move to the tail of the LRU list */
948 RemoveEntryList(¤t
->VacbLruListEntry
);
949 InsertTailList(&VacbLruListHead
, ¤t
->VacbLruListEntry
);
951 KeReleaseGuardedMutex(&ViewLock
);
954 * Return information about the VACB to the caller.
956 *UptoDate
= current
->Valid
;
957 *BaseAddress
= current
->BaseAddress
;
958 DPRINT("*BaseAddress %p\n", *BaseAddress
);
960 *BaseOffset
= current
->FileOffset
.QuadPart
;
961 return STATUS_SUCCESS
;
967 PROS_SHARED_CACHE_MAP SharedCacheMap
,
973 * FUNCTION: Request a page mapping for a shared cache map
978 ASSERT(SharedCacheMap
);
980 if (FileOffset
% VACB_MAPPING_GRANULARITY
!= 0)
982 DPRINT1("Bad fileoffset %I64x should be multiple of %x",
983 FileOffset
, VACB_MAPPING_GRANULARITY
);
984 KeBugCheck(CACHE_MANAGER
);
987 return CcRosGetVacb(SharedCacheMap
,
999 MEMORY_AREA
* MemoryArea
,
1002 SWAPENTRY SwapEntry
,
1005 ASSERT(SwapEntry
== 0);
1008 ASSERT(MmGetReferenceCountPage(Page
) == 1);
1009 MmReleasePageMemoryConsumer(MC_CACHE
, Page
);
1014 CcRosInternalFreeVacb (
1017 * FUNCTION: Releases a VACB associated with a shared cache map
1020 DPRINT("Freeing VACB 0x%p\n", Vacb
);
1022 if (Vacb
->SharedCacheMap
->Trace
)
1024 DPRINT1("CacheMap 0x%p: deleting VACB: 0x%p\n", Vacb
->SharedCacheMap
, Vacb
);
1028 MmLockAddressSpace(MmGetKernelAddressSpace());
1029 MmFreeMemoryArea(MmGetKernelAddressSpace(),
1033 MmUnlockAddressSpace(MmGetKernelAddressSpace());
1035 ExFreeToNPagedLookasideList(&VacbLookasideList
, Vacb
);
1036 return STATUS_SUCCESS
;
1045 IN PSECTION_OBJECT_POINTERS SectionObjectPointers
,
1046 IN PLARGE_INTEGER FileOffset OPTIONAL
,
1048 OUT PIO_STATUS_BLOCK IoStatus
)
1050 PROS_SHARED_CACHE_MAP SharedCacheMap
;
1051 LARGE_INTEGER Offset
;
1052 LONGLONG RemainingLength
;
1057 CCTRACE(CC_API_DEBUG
, "SectionObjectPointers=%p FileOffset=%p Length=%lu\n",
1058 SectionObjectPointers
, FileOffset
, Length
);
1060 DPRINT("CcFlushCache(SectionObjectPointers 0x%p, FileOffset 0x%p, Length %lu, IoStatus 0x%p)\n",
1061 SectionObjectPointers
, FileOffset
, Length
, IoStatus
);
1063 if (SectionObjectPointers
&& SectionObjectPointers
->SharedCacheMap
)
1065 SharedCacheMap
= SectionObjectPointers
->SharedCacheMap
;
1066 ASSERT(SharedCacheMap
);
1069 Offset
= *FileOffset
;
1070 RemainingLength
= Length
;
1074 Offset
.QuadPart
= 0;
1075 RemainingLength
= SharedCacheMap
->FileSize
.QuadPart
;
1080 IoStatus
->Status
= STATUS_SUCCESS
;
1081 IoStatus
->Information
= 0;
1084 while (RemainingLength
> 0)
1086 current
= CcRosLookupVacb(SharedCacheMap
, Offset
.QuadPart
);
1087 if (current
!= NULL
)
1091 Status
= CcRosFlushVacb(current
);
1092 if (!NT_SUCCESS(Status
) && IoStatus
!= NULL
)
1094 IoStatus
->Status
= Status
;
1098 CcRosReleaseVacbLock(current
);
1100 KeAcquireGuardedMutex(&ViewLock
);
1101 KeAcquireSpinLock(&SharedCacheMap
->CacheMapLock
, &oldIrql
);
1102 CcRosVacbDecRefCount(current
);
1103 KeReleaseSpinLock(&SharedCacheMap
->CacheMapLock
, oldIrql
);
1104 KeReleaseGuardedMutex(&ViewLock
);
1107 Offset
.QuadPart
+= VACB_MAPPING_GRANULARITY
;
1108 RemainingLength
-= min(RemainingLength
, VACB_MAPPING_GRANULARITY
);
1115 IoStatus
->Status
= STATUS_INVALID_PARAMETER
;
1122 CcRosDeleteFileCache (
1123 PFILE_OBJECT FileObject
,
1124 PROS_SHARED_CACHE_MAP SharedCacheMap
)
1126 * FUNCTION: Releases the shared cache map associated with a file object
1129 PLIST_ENTRY current_entry
;
1131 LIST_ENTRY FreeList
;
1134 ASSERT(SharedCacheMap
);
1136 SharedCacheMap
->OpenCount
++;
1137 KeReleaseGuardedMutex(&ViewLock
);
1139 CcFlushCache(FileObject
->SectionObjectPointer
, NULL
, 0, NULL
);
1141 KeAcquireGuardedMutex(&ViewLock
);
1142 SharedCacheMap
->OpenCount
--;
1143 if (SharedCacheMap
->OpenCount
== 0)
1147 FileObject
->SectionObjectPointer
->SharedCacheMap
= NULL
;
1152 InitializeListHead(&FreeList
);
1153 KeAcquireSpinLock(&SharedCacheMap
->CacheMapLock
, &oldIrql
);
1154 while (!IsListEmpty(&SharedCacheMap
->CacheMapVacbListHead
))
1156 current_entry
= RemoveTailList(&SharedCacheMap
->CacheMapVacbListHead
);
1157 current
= CONTAINING_RECORD(current_entry
, ROS_VACB
, CacheMapVacbListEntry
);
1158 RemoveEntryList(¤t
->VacbLruListEntry
);
1161 RemoveEntryList(¤t
->DirtyVacbListEntry
);
1162 CcTotalDirtyPages
-= VACB_MAPPING_GRANULARITY
/ PAGE_SIZE
;
1163 current
->SharedCacheMap
->DirtyPages
-= 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 SharedCacheMap
->DirtyPages
= 0;
1352 KeInitializeSpinLock(&SharedCacheMap
->CacheMapLock
);
1353 InitializeListHead(&SharedCacheMap
->CacheMapVacbListHead
);
1354 FileObject
->SectionObjectPointer
->SharedCacheMap
= SharedCacheMap
;
1356 KeAcquireSpinLock(&iSharedCacheMapLock
, &OldIrql
);
1357 InsertTailList(&CcCleanSharedCacheMapList
, &SharedCacheMap
->SharedCacheMapLinks
);
1358 KeReleaseSpinLock(&iSharedCacheMapLock
, OldIrql
);
1360 if (FileObject
->PrivateCacheMap
== NULL
)
1362 FileObject
->PrivateCacheMap
= SharedCacheMap
;
1363 SharedCacheMap
->OpenCount
++;
1365 KeReleaseGuardedMutex(&ViewLock
);
1367 return STATUS_SUCCESS
;
1375 CcGetFileObjectFromSectionPtrs (
1376 IN PSECTION_OBJECT_POINTERS SectionObjectPointers
)
1378 PROS_SHARED_CACHE_MAP SharedCacheMap
;
1380 CCTRACE(CC_API_DEBUG
, "SectionObjectPointers=%p\n", SectionObjectPointers
);
1382 if (SectionObjectPointers
&& SectionObjectPointers
->SharedCacheMap
)
1384 SharedCacheMap
= SectionObjectPointers
->SharedCacheMap
;
1385 ASSERT(SharedCacheMap
);
1386 return SharedCacheMap
->FileObject
;
1393 CcShutdownLazyWriter (
1396 /* Simply set the event, lazy writer will stop when it's done */
1397 KeSetEvent(&iLazyWriterShutdown
, IO_DISK_INCREMENT
, FALSE
);
1409 OBJECT_ATTRIBUTES ObjectAttributes
;
1411 DPRINT("CcInitView()\n");
1413 InitializeListHead(&DirtyVacbListHead
);
1414 InitializeListHead(&VacbLruListHead
);
1415 InitializeListHead(&CcDeferredWrites
);
1416 InitializeListHead(&CcCleanSharedCacheMapList
);
1417 KeInitializeSpinLock(&CcDeferredWriteSpinLock
);
1418 KeInitializeSpinLock(&iSharedCacheMapLock
);
1419 KeInitializeGuardedMutex(&ViewLock
);
1420 ExInitializeNPagedLookasideList(&iBcbLookasideList
,
1424 sizeof(INTERNAL_BCB
),
1427 ExInitializeNPagedLookasideList(&SharedCacheMapLookasideList
,
1431 sizeof(ROS_SHARED_CACHE_MAP
),
1432 TAG_SHARED_CACHE_MAP
,
1434 ExInitializeNPagedLookasideList(&VacbLookasideList
,
1442 MmInitializeMemoryConsumer(MC_CACHE
, CcRosTrimCache
);
1444 /* Initialize lazy writer events */
1445 KeInitializeEvent(&iLazyWriterShutdown
, SynchronizationEvent
, FALSE
);
1446 KeInitializeEvent(&iLazyWriterNotify
, NotificationEvent
, FALSE
);
1448 /* Define lazy writer threshold, depending on system type */
1449 switch (MmQuerySystemSize())
1452 CcDirtyPageThreshold
= MmNumberOfPhysicalPages
/ 8;
1455 case MmMediumSystem
:
1456 CcDirtyPageThreshold
= MmNumberOfPhysicalPages
/ 4;
1460 CcDirtyPageThreshold
= MmNumberOfPhysicalPages
/ 8 + MmNumberOfPhysicalPages
/ 4;
1464 /* Start the lazy writer thread */
1465 InitializeObjectAttributes(&ObjectAttributes
,
1470 Status
= PsCreateSystemThread(&LazyWriter
,
1477 if (!NT_SUCCESS(Status
))
1483 Status
= NtSetInformationThread(LazyWriter
,
1487 ASSERT(NT_SUCCESS(Status
));
1489 /* Handle is not needed */
1490 ObCloseHandle(LazyWriter
, KernelMode
);
1492 CcInitCacheZeroPage();
1497 #if DBG && defined(KDBG)
1499 ExpKdbgExtFileCache(ULONG Argc
, PCHAR Argv
[])
1501 PLIST_ENTRY ListEntry
;
1502 UNICODE_STRING NoName
= RTL_CONSTANT_STRING(L
"No name for File");
1504 KdbpPrint(" Usage Summary (in kb)\n");
1505 KdbpPrint("Shared\t\tValid\tDirty\tName\n");
1506 /* No need to lock the spin lock here, we're in DBG */
1507 for (ListEntry
= CcCleanSharedCacheMapList
.Flink
;
1508 ListEntry
!= &CcCleanSharedCacheMapList
;
1509 ListEntry
= ListEntry
->Flink
)
1512 ULONG Valid
= 0, Dirty
= 0;
1513 PROS_SHARED_CACHE_MAP SharedCacheMap
;
1514 PUNICODE_STRING FileName
;
1516 SharedCacheMap
= CONTAINING_RECORD(ListEntry
, ROS_SHARED_CACHE_MAP
, SharedCacheMapLinks
);
1519 Dirty
= (SharedCacheMap
->DirtyPages
* PAGE_SIZE
) / 1024;
1521 /* First, count for all the associated VACB */
1522 for (Vacbs
= SharedCacheMap
->CacheMapVacbListHead
.Flink
;
1523 Vacbs
!= &SharedCacheMap
->CacheMapVacbListHead
;
1524 Vacbs
= Vacbs
->Flink
)
1528 Vacb
= CONTAINING_RECORD(Vacbs
, ROS_VACB
, CacheMapVacbListEntry
);
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
);