[NTOSKRNL] Honor files that shouldn't be lazy written
[reactos.git] / ntoskrnl / cc / view.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: ntoskrnl/cc/view.c
5 * PURPOSE: Cache manager
6 *
7 * PROGRAMMERS: David Welch (welch@mcmail.com)
8 * Pierre Schweitzer (pierre@reactos.org)
9 */
10
11 /* NOTES **********************************************************************
12 *
13 * This is not the NT implementation of a file cache nor anything much like
14 * it.
15 *
16 * The general procedure for a filesystem to implement a read or write
17 * dispatch routine is as follows
18 *
19 * (1) If caching for the FCB hasn't been initiated then so do by calling
20 * CcInitializeFileCache.
21 *
22 * (2) For each 4k region which is being read or written obtain a cache page
23 * by calling CcRequestCachePage.
24 *
25 * (3) If either the page is being read or not completely written, and it is
26 * not up to date then read its data from the underlying medium. If the read
27 * fails then call CcReleaseCachePage with VALID as FALSE and return a error.
28 *
29 * (4) Copy the data into or out of the page as necessary.
30 *
31 * (5) Release the cache page
32 */
33 /* INCLUDES ******************************************************************/
34
35 #include <ntoskrnl.h>
36 #define NDEBUG
37 #include <debug.h>
38
39 #if defined (ALLOC_PRAGMA)
40 #pragma alloc_text(INIT, CcInitView)
41 #endif
42
43 /* GLOBALS *******************************************************************/
44
45 LIST_ENTRY DirtyVacbListHead;
46 static LIST_ENTRY VacbLruListHead;
47
48 NPAGED_LOOKASIDE_LIST iBcbLookasideList;
49 static NPAGED_LOOKASIDE_LIST SharedCacheMapLookasideList;
50 static NPAGED_LOOKASIDE_LIST VacbLookasideList;
51
52 /* Internal vars (MS):
53 * - Threshold above which lazy writer will start action
54 * - Amount of dirty pages
55 * - List for deferred writes
56 * - Spinlock when dealing with the deferred list
57 * - List for "clean" shared cache maps
58 */
59 ULONG CcDirtyPageThreshold = 0;
60 ULONG CcTotalDirtyPages = 0;
61 LIST_ENTRY CcDeferredWrites;
62 KSPIN_LOCK CcDeferredWriteSpinLock;
63 LIST_ENTRY CcCleanSharedCacheMapList;
64
65 #if DBG
66 ULONG CcRosVacbIncRefCount_(PROS_VACB vacb, PCSTR file, INT line)
67 {
68 ULONG Refs;
69
70 Refs = InterlockedIncrement((PLONG)&vacb->ReferenceCount);
71 if (vacb->SharedCacheMap->Trace)
72 {
73 DbgPrint("(%s:%i) VACB %p ++RefCount=%lu, Dirty %u, PageOut %lu\n",
74 file, line, vacb, Refs, vacb->Dirty, vacb->PageOut);
75 }
76
77 return Refs;
78 }
79 ULONG CcRosVacbDecRefCount_(PROS_VACB vacb, PCSTR file, INT line)
80 {
81 ULONG Refs;
82
83 Refs = InterlockedDecrement((PLONG)&vacb->ReferenceCount);
84 ASSERT(!(Refs == 0 && vacb->Dirty));
85 if (vacb->SharedCacheMap->Trace)
86 {
87 DbgPrint("(%s:%i) VACB %p --RefCount=%lu, Dirty %u, PageOut %lu\n",
88 file, line, vacb, Refs, vacb->Dirty, vacb->PageOut);
89 }
90
91 if (Refs == 0)
92 {
93 CcRosInternalFreeVacb(vacb);
94 }
95
96 return Refs;
97 }
98 ULONG CcRosVacbGetRefCount_(PROS_VACB vacb, PCSTR file, INT line)
99 {
100 ULONG Refs;
101
102 Refs = InterlockedCompareExchange((PLONG)&vacb->ReferenceCount, 0, 0);
103 if (vacb->SharedCacheMap->Trace)
104 {
105 DbgPrint("(%s:%i) VACB %p ==RefCount=%lu, Dirty %u, PageOut %lu\n",
106 file, line, vacb, Refs, vacb->Dirty, vacb->PageOut);
107 }
108
109 return Refs;
110 }
111 #endif
112
113
114 /* FUNCTIONS *****************************************************************/
115
116 VOID
117 NTAPI
118 CcRosTraceCacheMap (
119 PROS_SHARED_CACHE_MAP SharedCacheMap,
120 BOOLEAN Trace )
121 {
122 #if DBG
123 KIRQL oldirql;
124 PLIST_ENTRY current_entry;
125 PROS_VACB current;
126
127 if (!SharedCacheMap)
128 return;
129
130 SharedCacheMap->Trace = Trace;
131
132 if (Trace)
133 {
134 DPRINT1("Enabling Tracing for CacheMap 0x%p:\n", SharedCacheMap);
135
136 oldirql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
137 KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
138
139 current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
140 while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
141 {
142 current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
143 current_entry = current_entry->Flink;
144
145 DPRINT1(" VACB 0x%p enabled, RefCount %lu, Dirty %u, PageOut %lu\n",
146 current, current->ReferenceCount, current->Dirty, current->PageOut );
147 }
148
149 KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
150 KeReleaseQueuedSpinLock(LockQueueMasterLock, oldirql);
151 }
152 else
153 {
154 DPRINT1("Disabling Tracing for CacheMap 0x%p:\n", SharedCacheMap);
155 }
156
157 #else
158 UNREFERENCED_PARAMETER(SharedCacheMap);
159 UNREFERENCED_PARAMETER(Trace);
160 #endif
161 }
162
163 NTSTATUS
164 NTAPI
165 CcRosFlushVacb (
166 PROS_VACB Vacb)
167 {
168 NTSTATUS Status;
169
170 CcRosUnmarkDirtyVacb(Vacb, TRUE);
171
172 Status = CcWriteVirtualAddress(Vacb);
173 if (!NT_SUCCESS(Status))
174 {
175 CcRosMarkDirtyVacb(Vacb);
176 }
177
178 return Status;
179 }
180
181 NTSTATUS
182 NTAPI
183 CcRosFlushDirtyPages (
184 ULONG Target,
185 PULONG Count,
186 BOOLEAN Wait,
187 BOOLEAN CalledFromLazy)
188 {
189 PLIST_ENTRY current_entry;
190 PROS_VACB current;
191 BOOLEAN Locked;
192 NTSTATUS Status;
193 KIRQL OldIrql;
194
195 DPRINT("CcRosFlushDirtyPages(Target %lu)\n", Target);
196
197 (*Count) = 0;
198
199 KeEnterCriticalRegion();
200 OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
201
202 current_entry = DirtyVacbListHead.Flink;
203 if (current_entry == &DirtyVacbListHead)
204 {
205 DPRINT("No Dirty pages\n");
206 }
207
208 while ((current_entry != &DirtyVacbListHead) && (Target > 0))
209 {
210 current = CONTAINING_RECORD(current_entry,
211 ROS_VACB,
212 DirtyVacbListEntry);
213 current_entry = current_entry->Flink;
214
215 CcRosVacbIncRefCount(current);
216
217 /* When performing lazy write, don't handle temporary files */
218 if (CalledFromLazy &&
219 BooleanFlagOn(current->SharedCacheMap->FileObject->Flags, FO_TEMPORARY_FILE))
220 {
221 CcRosVacbDecRefCount(current);
222 continue;
223 }
224
225 /* Don't attempt to lazy write the files that asked not to */
226 if (CalledFromLazy &&
227 BooleanFlagOn(current->SharedCacheMap->Flags, WRITEBEHIND_DISABLED))
228 {
229 CcRosVacbDecRefCount(current);
230 continue;
231 }
232
233 ASSERT(current->Dirty);
234
235 KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
236
237 Locked = current->SharedCacheMap->Callbacks->AcquireForLazyWrite(
238 current->SharedCacheMap->LazyWriteContext, Wait);
239 if (!Locked)
240 {
241 OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
242 CcRosVacbDecRefCount(current);
243 continue;
244 }
245
246 Status = CcRosFlushVacb(current);
247
248 current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
249 current->SharedCacheMap->LazyWriteContext);
250
251 OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
252 CcRosVacbDecRefCount(current);
253
254 if (!NT_SUCCESS(Status) && (Status != STATUS_END_OF_FILE) &&
255 (Status != STATUS_MEDIA_WRITE_PROTECTED))
256 {
257 DPRINT1("CC: Failed to flush VACB.\n");
258 }
259 else
260 {
261 ULONG PagesFreed;
262
263 /* How many pages did we free? */
264 PagesFreed = VACB_MAPPING_GRANULARITY / PAGE_SIZE;
265 (*Count) += PagesFreed;
266
267 /* Make sure we don't overflow target! */
268 if (Target < PagesFreed)
269 {
270 /* If we would have, jump to zero directly */
271 Target = 0;
272 }
273 else
274 {
275 Target -= PagesFreed;
276 }
277 }
278
279 current_entry = DirtyVacbListHead.Flink;
280 }
281
282 KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
283 KeLeaveCriticalRegion();
284
285 DPRINT("CcRosFlushDirtyPages() finished\n");
286 return STATUS_SUCCESS;
287 }
288
289 NTSTATUS
290 CcRosTrimCache (
291 ULONG Target,
292 ULONG Priority,
293 PULONG NrFreed)
294 /*
295 * FUNCTION: Try to free some memory from the file cache.
296 * ARGUMENTS:
297 * Target - The number of pages to be freed.
298 * Priority - The priority of free (currently unused).
299 * NrFreed - Points to a variable where the number of pages
300 * actually freed is returned.
301 */
302 {
303 PLIST_ENTRY current_entry;
304 PROS_VACB current;
305 ULONG PagesFreed;
306 KIRQL oldIrql;
307 LIST_ENTRY FreeList;
308 PFN_NUMBER Page;
309 ULONG i;
310 BOOLEAN FlushedPages = FALSE;
311
312 DPRINT("CcRosTrimCache(Target %lu)\n", Target);
313
314 InitializeListHead(&FreeList);
315
316 *NrFreed = 0;
317
318 retry:
319 oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
320
321 current_entry = VacbLruListHead.Flink;
322 while (current_entry != &VacbLruListHead)
323 {
324 ULONG Refs;
325
326 current = CONTAINING_RECORD(current_entry,
327 ROS_VACB,
328 VacbLruListEntry);
329 current_entry = current_entry->Flink;
330
331 KeAcquireSpinLockAtDpcLevel(&current->SharedCacheMap->CacheMapLock);
332
333 /* Reference the VACB */
334 CcRosVacbIncRefCount(current);
335
336 /* Check if it's mapped and not dirty */
337 if (InterlockedCompareExchange((PLONG)&current->MappedCount, 0, 0) > 0 && !current->Dirty)
338 {
339 /* We have to break these locks because Cc sucks */
340 KeReleaseSpinLockFromDpcLevel(&current->SharedCacheMap->CacheMapLock);
341 KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
342
343 /* Page out the VACB */
344 for (i = 0; i < VACB_MAPPING_GRANULARITY / PAGE_SIZE; i++)
345 {
346 Page = (PFN_NUMBER)(MmGetPhysicalAddress((PUCHAR)current->BaseAddress + (i * PAGE_SIZE)).QuadPart >> PAGE_SHIFT);
347
348 MmPageOutPhysicalAddress(Page);
349 }
350
351 /* Reacquire the locks */
352 oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
353 KeAcquireSpinLockAtDpcLevel(&current->SharedCacheMap->CacheMapLock);
354 }
355
356 /* Dereference the VACB */
357 Refs = CcRosVacbDecRefCount(current);
358
359 /* Check if we can free this entry now */
360 if (Refs < 2)
361 {
362 ASSERT(!current->Dirty);
363 ASSERT(!current->MappedCount);
364 ASSERT(Refs == 1);
365
366 RemoveEntryList(&current->CacheMapVacbListEntry);
367 RemoveEntryList(&current->VacbLruListEntry);
368 InitializeListHead(&current->VacbLruListEntry);
369 InsertHeadList(&FreeList, &current->CacheMapVacbListEntry);
370
371 /* Calculate how many pages we freed for Mm */
372 PagesFreed = min(VACB_MAPPING_GRANULARITY / PAGE_SIZE, Target);
373 Target -= PagesFreed;
374 (*NrFreed) += PagesFreed;
375 }
376
377 KeReleaseSpinLockFromDpcLevel(&current->SharedCacheMap->CacheMapLock);
378 }
379
380 KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
381
382 /* Try flushing pages if we haven't met our target */
383 if ((Target > 0) && !FlushedPages)
384 {
385 /* Flush dirty pages to disk */
386 CcRosFlushDirtyPages(Target, &PagesFreed, FALSE, FALSE);
387 FlushedPages = TRUE;
388
389 /* We can only swap as many pages as we flushed */
390 if (PagesFreed < Target) Target = PagesFreed;
391
392 /* Check if we flushed anything */
393 if (PagesFreed != 0)
394 {
395 /* Try again after flushing dirty pages */
396 DPRINT("Flushed %lu dirty cache pages to disk\n", PagesFreed);
397 goto retry;
398 }
399 }
400
401 while (!IsListEmpty(&FreeList))
402 {
403 ULONG Refs;
404
405 current_entry = RemoveHeadList(&FreeList);
406 current = CONTAINING_RECORD(current_entry,
407 ROS_VACB,
408 CacheMapVacbListEntry);
409 InitializeListHead(&current->CacheMapVacbListEntry);
410 Refs = CcRosVacbDecRefCount(current);
411 ASSERT(Refs == 0);
412 }
413
414 DPRINT("Evicted %lu cache pages\n", (*NrFreed));
415
416 return STATUS_SUCCESS;
417 }
418
419 NTSTATUS
420 NTAPI
421 CcRosReleaseVacb (
422 PROS_SHARED_CACHE_MAP SharedCacheMap,
423 PROS_VACB Vacb,
424 BOOLEAN Valid,
425 BOOLEAN Dirty,
426 BOOLEAN Mapped)
427 {
428 ULONG Refs;
429 ASSERT(SharedCacheMap);
430
431 DPRINT("CcRosReleaseVacb(SharedCacheMap 0x%p, Vacb 0x%p, Valid %u)\n",
432 SharedCacheMap, Vacb, Valid);
433
434 Vacb->Valid = Valid;
435
436 if (Dirty && !Vacb->Dirty)
437 {
438 CcRosMarkDirtyVacb(Vacb);
439 }
440
441 if (Mapped)
442 {
443 if (InterlockedIncrement((PLONG)&Vacb->MappedCount) == 1)
444 {
445 CcRosVacbIncRefCount(Vacb);
446 }
447 }
448
449 Refs = CcRosVacbDecRefCount(Vacb);
450 ASSERT(Refs > 0);
451
452 return STATUS_SUCCESS;
453 }
454
455 /* Returns with VACB Lock Held! */
456 PROS_VACB
457 NTAPI
458 CcRosLookupVacb (
459 PROS_SHARED_CACHE_MAP SharedCacheMap,
460 LONGLONG FileOffset)
461 {
462 PLIST_ENTRY current_entry;
463 PROS_VACB current;
464 KIRQL oldIrql;
465
466 ASSERT(SharedCacheMap);
467
468 DPRINT("CcRosLookupVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
469 SharedCacheMap, FileOffset);
470
471 oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
472 KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
473
474 current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
475 while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
476 {
477 current = CONTAINING_RECORD(current_entry,
478 ROS_VACB,
479 CacheMapVacbListEntry);
480 if (IsPointInRange(current->FileOffset.QuadPart,
481 VACB_MAPPING_GRANULARITY,
482 FileOffset))
483 {
484 CcRosVacbIncRefCount(current);
485 KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
486 KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
487 return current;
488 }
489 if (current->FileOffset.QuadPart > FileOffset)
490 break;
491 current_entry = current_entry->Flink;
492 }
493
494 KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
495 KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
496
497 return NULL;
498 }
499
500 VOID
501 NTAPI
502 CcRosMarkDirtyVacb (
503 PROS_VACB Vacb)
504 {
505 KIRQL oldIrql;
506 PROS_SHARED_CACHE_MAP SharedCacheMap;
507
508 SharedCacheMap = Vacb->SharedCacheMap;
509
510 oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
511 KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
512
513 ASSERT(!Vacb->Dirty);
514
515 InsertTailList(&DirtyVacbListHead, &Vacb->DirtyVacbListEntry);
516 CcTotalDirtyPages += VACB_MAPPING_GRANULARITY / PAGE_SIZE;
517 Vacb->SharedCacheMap->DirtyPages += VACB_MAPPING_GRANULARITY / PAGE_SIZE;
518 CcRosVacbIncRefCount(Vacb);
519
520 /* Move to the tail of the LRU list */
521 RemoveEntryList(&Vacb->VacbLruListEntry);
522 InsertTailList(&VacbLruListHead, &Vacb->VacbLruListEntry);
523
524 Vacb->Dirty = TRUE;
525
526 KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
527
528 /* Schedule a lazy writer run to now that we have dirty VACB */
529 if (!LazyWriter.ScanActive)
530 {
531 CcScheduleLazyWriteScan(FALSE);
532 }
533 KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
534 }
535
536 VOID
537 NTAPI
538 CcRosUnmarkDirtyVacb (
539 PROS_VACB Vacb,
540 BOOLEAN LockViews)
541 {
542 KIRQL oldIrql;
543 PROS_SHARED_CACHE_MAP SharedCacheMap;
544
545 SharedCacheMap = Vacb->SharedCacheMap;
546
547 if (LockViews)
548 {
549 oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
550 KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
551 }
552
553 ASSERT(Vacb->Dirty);
554
555 Vacb->Dirty = FALSE;
556
557 RemoveEntryList(&Vacb->DirtyVacbListEntry);
558 InitializeListHead(&Vacb->DirtyVacbListEntry);
559 CcTotalDirtyPages -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
560 Vacb->SharedCacheMap->DirtyPages -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
561 CcRosVacbDecRefCount(Vacb);
562
563 if (LockViews)
564 {
565 KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
566 KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
567 }
568 }
569
570 NTSTATUS
571 NTAPI
572 CcRosMarkDirtyFile (
573 PROS_SHARED_CACHE_MAP SharedCacheMap,
574 LONGLONG FileOffset)
575 {
576 PROS_VACB Vacb;
577
578 ASSERT(SharedCacheMap);
579
580 DPRINT("CcRosMarkDirtyVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
581 SharedCacheMap, FileOffset);
582
583 Vacb = CcRosLookupVacb(SharedCacheMap, FileOffset);
584 if (Vacb == NULL)
585 {
586 KeBugCheck(CACHE_MANAGER);
587 }
588
589 CcRosReleaseVacb(SharedCacheMap, Vacb, Vacb->Valid, TRUE, FALSE);
590
591 return STATUS_SUCCESS;
592 }
593
594 /*
595 * Note: this is not the contrary function of
596 * CcRosMapVacbInKernelSpace()
597 */
598 NTSTATUS
599 NTAPI
600 CcRosUnmapVacb (
601 PROS_SHARED_CACHE_MAP SharedCacheMap,
602 LONGLONG FileOffset,
603 BOOLEAN NowDirty)
604 {
605 PROS_VACB Vacb;
606
607 ASSERT(SharedCacheMap);
608
609 DPRINT("CcRosUnmapVacb(SharedCacheMap 0x%p, FileOffset %I64u, NowDirty %u)\n",
610 SharedCacheMap, FileOffset, NowDirty);
611
612 Vacb = CcRosLookupVacb(SharedCacheMap, FileOffset);
613 if (Vacb == NULL)
614 {
615 return STATUS_UNSUCCESSFUL;
616 }
617
618 ASSERT(Vacb->MappedCount != 0);
619 if (InterlockedDecrement((PLONG)&Vacb->MappedCount) == 0)
620 {
621 CcRosVacbDecRefCount(Vacb);
622 }
623
624 CcRosReleaseVacb(SharedCacheMap, Vacb, Vacb->Valid, NowDirty, FALSE);
625
626 return STATUS_SUCCESS;
627 }
628
629 static
630 NTSTATUS
631 CcRosMapVacbInKernelSpace(
632 PROS_VACB Vacb)
633 {
634 ULONG i;
635 NTSTATUS Status;
636 ULONG_PTR NumberOfPages;
637 PVOID BaseAddress = NULL;
638
639 /* Create a memory area. */
640 MmLockAddressSpace(MmGetKernelAddressSpace());
641 Status = MmCreateMemoryArea(MmGetKernelAddressSpace(),
642 0, // nothing checks for VACB mareas, so set to 0
643 &BaseAddress,
644 VACB_MAPPING_GRANULARITY,
645 PAGE_READWRITE,
646 (PMEMORY_AREA*)&Vacb->MemoryArea,
647 0,
648 PAGE_SIZE);
649 ASSERT(Vacb->BaseAddress == NULL);
650 Vacb->BaseAddress = BaseAddress;
651 MmUnlockAddressSpace(MmGetKernelAddressSpace());
652 if (!NT_SUCCESS(Status))
653 {
654 DPRINT1("MmCreateMemoryArea failed with %lx for VACB %p\n", Status, Vacb);
655 return Status;
656 }
657
658 ASSERT(((ULONG_PTR)Vacb->BaseAddress % PAGE_SIZE) == 0);
659 ASSERT((ULONG_PTR)Vacb->BaseAddress > (ULONG_PTR)MmSystemRangeStart);
660 ASSERT((ULONG_PTR)Vacb->BaseAddress + VACB_MAPPING_GRANULARITY - 1 > (ULONG_PTR)MmSystemRangeStart);
661
662 /* Create a virtual mapping for this memory area */
663 NumberOfPages = BYTES_TO_PAGES(VACB_MAPPING_GRANULARITY);
664 for (i = 0; i < NumberOfPages; i++)
665 {
666 PFN_NUMBER PageFrameNumber;
667
668 MI_SET_USAGE(MI_USAGE_CACHE);
669 Status = MmRequestPageMemoryConsumer(MC_CACHE, TRUE, &PageFrameNumber);
670 if (PageFrameNumber == 0)
671 {
672 DPRINT1("Unable to allocate page\n");
673 KeBugCheck(MEMORY_MANAGEMENT);
674 }
675
676 ASSERT(BaseAddress == Vacb->BaseAddress);
677 ASSERT(i * PAGE_SIZE < VACB_MAPPING_GRANULARITY);
678 ASSERT((ULONG_PTR)Vacb->BaseAddress + (i * PAGE_SIZE) >= (ULONG_PTR)BaseAddress);
679 ASSERT((ULONG_PTR)Vacb->BaseAddress + (i * PAGE_SIZE) > (ULONG_PTR)MmSystemRangeStart);
680
681 Status = MmCreateVirtualMapping(NULL,
682 (PVOID)((ULONG_PTR)Vacb->BaseAddress + (i * PAGE_SIZE)),
683 PAGE_READWRITE,
684 &PageFrameNumber,
685 1);
686 if (!NT_SUCCESS(Status))
687 {
688 DPRINT1("Unable to create virtual mapping\n");
689 KeBugCheck(MEMORY_MANAGEMENT);
690 }
691 }
692
693 return STATUS_SUCCESS;
694 }
695
696 static
697 BOOLEAN
698 CcRosFreeUnusedVacb (
699 PULONG Count)
700 {
701 ULONG cFreed;
702 BOOLEAN Freed;
703 KIRQL oldIrql;
704 PROS_VACB current;
705 LIST_ENTRY FreeList;
706 PLIST_ENTRY current_entry;
707
708 cFreed = 0;
709 Freed = FALSE;
710 InitializeListHead(&FreeList);
711
712 oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
713
714 /* Browse all the available VACB */
715 current_entry = VacbLruListHead.Flink;
716 while (current_entry != &VacbLruListHead)
717 {
718 ULONG Refs;
719
720 current = CONTAINING_RECORD(current_entry,
721 ROS_VACB,
722 VacbLruListEntry);
723 current_entry = current_entry->Flink;
724
725 KeAcquireSpinLockAtDpcLevel(&current->SharedCacheMap->CacheMapLock);
726
727 /* Only deal with unused VACB, we will free them */
728 Refs = CcRosVacbGetRefCount(current);
729 if (Refs < 2)
730 {
731 ASSERT(!current->Dirty);
732 ASSERT(!current->MappedCount);
733 ASSERT(Refs == 1);
734
735 /* Reset and move to free list */
736 RemoveEntryList(&current->CacheMapVacbListEntry);
737 RemoveEntryList(&current->VacbLruListEntry);
738 InitializeListHead(&current->VacbLruListEntry);
739 InsertHeadList(&FreeList, &current->CacheMapVacbListEntry);
740 }
741
742 KeReleaseSpinLockFromDpcLevel(&current->SharedCacheMap->CacheMapLock);
743
744 }
745
746 KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
747
748 /* And now, free any of the found VACB, that'll free memory! */
749 while (!IsListEmpty(&FreeList))
750 {
751 ULONG Refs;
752
753 current_entry = RemoveHeadList(&FreeList);
754 current = CONTAINING_RECORD(current_entry,
755 ROS_VACB,
756 CacheMapVacbListEntry);
757 InitializeListHead(&current->CacheMapVacbListEntry);
758 Refs = CcRosVacbDecRefCount(current);
759 ASSERT(Refs == 0);
760 ++cFreed;
761 }
762
763 /* If we freed at least one VACB, return success */
764 if (cFreed != 0)
765 {
766 Freed = TRUE;
767 }
768
769 /* If caller asked for free count, return it */
770 if (Count != NULL)
771 {
772 *Count = cFreed;
773 }
774
775 return Freed;
776 }
777
778 static
779 NTSTATUS
780 CcRosCreateVacb (
781 PROS_SHARED_CACHE_MAP SharedCacheMap,
782 LONGLONG FileOffset,
783 PROS_VACB *Vacb)
784 {
785 PROS_VACB current;
786 PROS_VACB previous;
787 PLIST_ENTRY current_entry;
788 NTSTATUS Status;
789 KIRQL oldIrql;
790 ULONG Refs;
791 BOOLEAN Retried;
792
793 ASSERT(SharedCacheMap);
794
795 DPRINT("CcRosCreateVacb()\n");
796
797 if (FileOffset >= SharedCacheMap->SectionSize.QuadPart)
798 {
799 *Vacb = NULL;
800 return STATUS_INVALID_PARAMETER;
801 }
802
803 current = ExAllocateFromNPagedLookasideList(&VacbLookasideList);
804 current->BaseAddress = NULL;
805 current->Valid = FALSE;
806 current->Dirty = FALSE;
807 current->PageOut = FALSE;
808 current->FileOffset.QuadPart = ROUND_DOWN(FileOffset, VACB_MAPPING_GRANULARITY);
809 current->SharedCacheMap = SharedCacheMap;
810 #if DBG
811 if (SharedCacheMap->Trace)
812 {
813 DPRINT1("CacheMap 0x%p: new VACB: 0x%p\n", SharedCacheMap, current);
814 }
815 #endif
816 current->MappedCount = 0;
817 current->ReferenceCount = 0;
818 InitializeListHead(&current->CacheMapVacbListEntry);
819 InitializeListHead(&current->DirtyVacbListEntry);
820 InitializeListHead(&current->VacbLruListEntry);
821
822 CcRosVacbIncRefCount(current);
823
824 Retried = FALSE;
825 Retry:
826 /* Map VACB in kernel space */
827 Status = CcRosMapVacbInKernelSpace(current);
828 if (!NT_SUCCESS(Status))
829 {
830 ULONG Freed;
831 /* If no space left, try to prune unused VACB
832 * to recover space to map our VACB
833 * If it succeed, retry to map, otherwise
834 * just fail.
835 */
836 if (!Retried && CcRosFreeUnusedVacb(&Freed))
837 {
838 DPRINT("Prunned %d VACB, trying again\n", Freed);
839 Retried = TRUE;
840 goto Retry;
841 }
842
843 ExFreeToNPagedLookasideList(&VacbLookasideList, current);
844 return Status;
845 }
846
847 oldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
848
849 *Vacb = current;
850 /* There is window between the call to CcRosLookupVacb
851 * and CcRosCreateVacb. We must check if a VACB for the
852 * file offset exist. If there is a VACB, we release
853 * our newly created VACB and return the existing one.
854 */
855 KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
856 current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
857 previous = NULL;
858 while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
859 {
860 current = CONTAINING_RECORD(current_entry,
861 ROS_VACB,
862 CacheMapVacbListEntry);
863 if (IsPointInRange(current->FileOffset.QuadPart,
864 VACB_MAPPING_GRANULARITY,
865 FileOffset))
866 {
867 CcRosVacbIncRefCount(current);
868 KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
869 #if DBG
870 if (SharedCacheMap->Trace)
871 {
872 DPRINT1("CacheMap 0x%p: deleting newly created VACB 0x%p ( found existing one 0x%p )\n",
873 SharedCacheMap,
874 (*Vacb),
875 current);
876 }
877 #endif
878 KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
879
880 Refs = CcRosVacbDecRefCount(*Vacb);
881 ASSERT(Refs == 0);
882
883 *Vacb = current;
884 return STATUS_SUCCESS;
885 }
886 if (current->FileOffset.QuadPart < FileOffset)
887 {
888 ASSERT(previous == NULL ||
889 previous->FileOffset.QuadPart < current->FileOffset.QuadPart);
890 previous = current;
891 }
892 if (current->FileOffset.QuadPart > FileOffset)
893 break;
894 current_entry = current_entry->Flink;
895 }
896 /* There was no existing VACB. */
897 current = *Vacb;
898 if (previous)
899 {
900 InsertHeadList(&previous->CacheMapVacbListEntry, &current->CacheMapVacbListEntry);
901 }
902 else
903 {
904 InsertHeadList(&SharedCacheMap->CacheMapVacbListHead, &current->CacheMapVacbListEntry);
905 }
906 KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
907 InsertTailList(&VacbLruListHead, &current->VacbLruListEntry);
908 KeReleaseQueuedSpinLock(LockQueueMasterLock, oldIrql);
909
910 MI_SET_USAGE(MI_USAGE_CACHE);
911 #if MI_TRACE_PFNS
912 if ((SharedCacheMap->FileObject) && (SharedCacheMap->FileObject->FileName.Buffer))
913 {
914 PWCHAR pos;
915 ULONG len = 0;
916 pos = wcsrchr(SharedCacheMap->FileObject->FileName.Buffer, '\\');
917 if (pos)
918 {
919 len = wcslen(pos) * sizeof(WCHAR);
920 snprintf(MI_PFN_CURRENT_PROCESS_NAME, min(16, len), "%S", pos);
921 }
922 else
923 {
924 snprintf(MI_PFN_CURRENT_PROCESS_NAME, min(16, len), "%wZ", &SharedCacheMap->FileObject->FileName);
925 }
926 }
927 #endif
928
929 /* Reference it to allow release */
930 CcRosVacbIncRefCount(current);
931
932 return Status;
933 }
934
935 NTSTATUS
936 NTAPI
937 CcRosGetVacb (
938 PROS_SHARED_CACHE_MAP SharedCacheMap,
939 LONGLONG FileOffset,
940 PLONGLONG BaseOffset,
941 PVOID* BaseAddress,
942 PBOOLEAN UptoDate,
943 PROS_VACB *Vacb)
944 {
945 PROS_VACB current;
946 NTSTATUS Status;
947 ULONG Refs;
948 KIRQL OldIrql;
949
950 ASSERT(SharedCacheMap);
951
952 DPRINT("CcRosGetVacb()\n");
953
954 /*
955 * Look for a VACB already mapping the same data.
956 */
957 current = CcRosLookupVacb(SharedCacheMap, FileOffset);
958 if (current == NULL)
959 {
960 /*
961 * Otherwise create a new VACB.
962 */
963 Status = CcRosCreateVacb(SharedCacheMap, FileOffset, &current);
964 if (!NT_SUCCESS(Status))
965 {
966 return Status;
967 }
968 }
969
970 Refs = CcRosVacbGetRefCount(current);
971
972 OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
973
974 /* Move to the tail of the LRU list */
975 RemoveEntryList(&current->VacbLruListEntry);
976 InsertTailList(&VacbLruListHead, &current->VacbLruListEntry);
977
978 KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
979
980 /*
981 * Return information about the VACB to the caller.
982 */
983 *UptoDate = current->Valid;
984 *BaseAddress = current->BaseAddress;
985 DPRINT("*BaseAddress %p\n", *BaseAddress);
986 *Vacb = current;
987 *BaseOffset = current->FileOffset.QuadPart;
988
989 ASSERT(Refs > 1);
990
991 return STATUS_SUCCESS;
992 }
993
994 NTSTATUS
995 NTAPI
996 CcRosRequestVacb (
997 PROS_SHARED_CACHE_MAP SharedCacheMap,
998 LONGLONG FileOffset,
999 PVOID* BaseAddress,
1000 PBOOLEAN UptoDate,
1001 PROS_VACB *Vacb)
1002 /*
1003 * FUNCTION: Request a page mapping for a shared cache map
1004 */
1005 {
1006 LONGLONG BaseOffset;
1007
1008 ASSERT(SharedCacheMap);
1009
1010 if (FileOffset % VACB_MAPPING_GRANULARITY != 0)
1011 {
1012 DPRINT1("Bad fileoffset %I64x should be multiple of %x",
1013 FileOffset, VACB_MAPPING_GRANULARITY);
1014 KeBugCheck(CACHE_MANAGER);
1015 }
1016
1017 return CcRosGetVacb(SharedCacheMap,
1018 FileOffset,
1019 &BaseOffset,
1020 BaseAddress,
1021 UptoDate,
1022 Vacb);
1023 }
1024
1025 static
1026 VOID
1027 CcFreeCachePage (
1028 PVOID Context,
1029 MEMORY_AREA* MemoryArea,
1030 PVOID Address,
1031 PFN_NUMBER Page,
1032 SWAPENTRY SwapEntry,
1033 BOOLEAN Dirty)
1034 {
1035 ASSERT(SwapEntry == 0);
1036 if (Page != 0)
1037 {
1038 ASSERT(MmGetReferenceCountPage(Page) == 1);
1039 MmReleasePageMemoryConsumer(MC_CACHE, Page);
1040 }
1041 }
1042
1043 NTSTATUS
1044 CcRosInternalFreeVacb (
1045 PROS_VACB Vacb)
1046 /*
1047 * FUNCTION: Releases a VACB associated with a shared cache map
1048 */
1049 {
1050 DPRINT("Freeing VACB 0x%p\n", Vacb);
1051 #if DBG
1052 if (Vacb->SharedCacheMap->Trace)
1053 {
1054 DPRINT1("CacheMap 0x%p: deleting VACB: 0x%p\n", Vacb->SharedCacheMap, Vacb);
1055 }
1056 #endif
1057
1058 MmLockAddressSpace(MmGetKernelAddressSpace());
1059 MmFreeMemoryArea(MmGetKernelAddressSpace(),
1060 Vacb->MemoryArea,
1061 CcFreeCachePage,
1062 NULL);
1063 MmUnlockAddressSpace(MmGetKernelAddressSpace());
1064
1065 if (Vacb->ReferenceCount != 0)
1066 {
1067 DPRINT1("Invalid free: %ld\n", Vacb->ReferenceCount);
1068 if (Vacb->SharedCacheMap->FileObject && Vacb->SharedCacheMap->FileObject->FileName.Length)
1069 {
1070 DPRINT1("For file: %wZ\n", &Vacb->SharedCacheMap->FileObject->FileName);
1071 }
1072 }
1073
1074 ASSERT(Vacb->ReferenceCount == 0);
1075 ASSERT(IsListEmpty(&Vacb->CacheMapVacbListEntry));
1076 ASSERT(IsListEmpty(&Vacb->DirtyVacbListEntry));
1077 ASSERT(IsListEmpty(&Vacb->VacbLruListEntry));
1078 RtlFillMemory(Vacb, sizeof(*Vacb), 0xfd);
1079 ExFreeToNPagedLookasideList(&VacbLookasideList, Vacb);
1080 return STATUS_SUCCESS;
1081 }
1082
1083 /*
1084 * @implemented
1085 */
1086 VOID
1087 NTAPI
1088 CcFlushCache (
1089 IN PSECTION_OBJECT_POINTERS SectionObjectPointers,
1090 IN PLARGE_INTEGER FileOffset OPTIONAL,
1091 IN ULONG Length,
1092 OUT PIO_STATUS_BLOCK IoStatus)
1093 {
1094 PROS_SHARED_CACHE_MAP SharedCacheMap;
1095 LARGE_INTEGER Offset;
1096 LONGLONG RemainingLength;
1097 PROS_VACB current;
1098 NTSTATUS Status;
1099
1100 CCTRACE(CC_API_DEBUG, "SectionObjectPointers=%p FileOffset=%p Length=%lu\n",
1101 SectionObjectPointers, FileOffset, Length);
1102
1103 DPRINT("CcFlushCache(SectionObjectPointers 0x%p, FileOffset 0x%p, Length %lu, IoStatus 0x%p)\n",
1104 SectionObjectPointers, FileOffset, Length, IoStatus);
1105
1106 if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
1107 {
1108 SharedCacheMap = SectionObjectPointers->SharedCacheMap;
1109 ASSERT(SharedCacheMap);
1110 if (FileOffset)
1111 {
1112 Offset = *FileOffset;
1113 RemainingLength = Length;
1114 }
1115 else
1116 {
1117 Offset.QuadPart = 0;
1118 RemainingLength = SharedCacheMap->FileSize.QuadPart;
1119 }
1120
1121 if (IoStatus)
1122 {
1123 IoStatus->Status = STATUS_SUCCESS;
1124 IoStatus->Information = 0;
1125 }
1126
1127 while (RemainingLength > 0)
1128 {
1129 current = CcRosLookupVacb(SharedCacheMap, Offset.QuadPart);
1130 if (current != NULL)
1131 {
1132 if (current->Dirty)
1133 {
1134 Status = CcRosFlushVacb(current);
1135 if (!NT_SUCCESS(Status) && IoStatus != NULL)
1136 {
1137 IoStatus->Status = Status;
1138 }
1139 }
1140
1141 CcRosReleaseVacb(SharedCacheMap, current, current->Valid, current->Dirty, FALSE);
1142 }
1143
1144 Offset.QuadPart += VACB_MAPPING_GRANULARITY;
1145 RemainingLength -= min(RemainingLength, VACB_MAPPING_GRANULARITY);
1146 }
1147 }
1148 else
1149 {
1150 if (IoStatus)
1151 {
1152 IoStatus->Status = STATUS_INVALID_PARAMETER;
1153 }
1154 }
1155 }
1156
1157 NTSTATUS
1158 NTAPI
1159 CcRosDeleteFileCache (
1160 PFILE_OBJECT FileObject,
1161 PROS_SHARED_CACHE_MAP SharedCacheMap,
1162 PKIRQL OldIrql)
1163 /*
1164 * FUNCTION: Releases the shared cache map associated with a file object
1165 */
1166 {
1167 PLIST_ENTRY current_entry;
1168 PROS_VACB current;
1169 LIST_ENTRY FreeList;
1170
1171 ASSERT(SharedCacheMap);
1172
1173 SharedCacheMap->OpenCount++;
1174 KeReleaseQueuedSpinLock(LockQueueMasterLock, *OldIrql);
1175
1176 CcFlushCache(FileObject->SectionObjectPointer, NULL, 0, NULL);
1177
1178 *OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
1179 SharedCacheMap->OpenCount--;
1180 if (SharedCacheMap->OpenCount == 0)
1181 {
1182 FileObject->SectionObjectPointer->SharedCacheMap = NULL;
1183
1184 /*
1185 * Release all VACBs
1186 */
1187 InitializeListHead(&FreeList);
1188 KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
1189 while (!IsListEmpty(&SharedCacheMap->CacheMapVacbListHead))
1190 {
1191 current_entry = RemoveTailList(&SharedCacheMap->CacheMapVacbListHead);
1192 KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
1193
1194 current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
1195 RemoveEntryList(&current->VacbLruListEntry);
1196 InitializeListHead(&current->VacbLruListEntry);
1197 if (current->Dirty)
1198 {
1199 KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
1200 CcRosUnmarkDirtyVacb(current, FALSE);
1201 KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
1202 DPRINT1("Freeing dirty VACB\n");
1203 }
1204 if (current->MappedCount != 0)
1205 {
1206 current->MappedCount = 0;
1207 NT_VERIFY(CcRosVacbDecRefCount(current) > 0);
1208 DPRINT1("Freeing mapped VACB\n");
1209 }
1210 InsertHeadList(&FreeList, &current->CacheMapVacbListEntry);
1211
1212 KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
1213 }
1214 #if DBG
1215 SharedCacheMap->Trace = FALSE;
1216 #endif
1217 KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
1218
1219 KeReleaseQueuedSpinLock(LockQueueMasterLock, *OldIrql);
1220 ObDereferenceObject(SharedCacheMap->FileObject);
1221
1222 while (!IsListEmpty(&FreeList))
1223 {
1224 ULONG Refs;
1225
1226 current_entry = RemoveTailList(&FreeList);
1227 current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
1228 InitializeListHead(&current->CacheMapVacbListEntry);
1229 Refs = CcRosVacbDecRefCount(current);
1230 #if DBG // CORE-14578
1231 if (Refs != 0)
1232 {
1233 DPRINT1("Leaking VACB %p attached to %p (%I64d)\n", current, FileObject, current->FileOffset.QuadPart);
1234 DPRINT1("There are: %d references left\n", Refs);
1235 DPRINT1("Map: %d\n", current->MappedCount);
1236 DPRINT1("Dirty: %d\n", current->Dirty);
1237 if (FileObject->FileName.Length != 0)
1238 {
1239 DPRINT1("File was: %wZ\n", &FileObject->FileName);
1240 }
1241 else if (FileObject->FsContext != NULL &&
1242 ((PFSRTL_COMMON_FCB_HEADER)(FileObject->FsContext))->NodeTypeCode == 0x0502 &&
1243 ((PFSRTL_COMMON_FCB_HEADER)(FileObject->FsContext))->NodeByteSize == 0x1F8 &&
1244 ((PUNICODE_STRING)(((PUCHAR)FileObject->FsContext) + 0x100))->Length != 0)
1245 {
1246 DPRINT1("File was: %wZ (FastFAT)\n", (PUNICODE_STRING)(((PUCHAR)FileObject->FsContext) + 0x100));
1247 }
1248 else
1249 {
1250 DPRINT1("No name for the file\n");
1251 }
1252 }
1253 #else
1254 ASSERT(Refs == 0);
1255 #endif
1256 }
1257
1258 *OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
1259 RemoveEntryList(&SharedCacheMap->SharedCacheMapLinks);
1260 KeReleaseQueuedSpinLock(LockQueueMasterLock, *OldIrql);
1261
1262 ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap);
1263 *OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
1264 }
1265 return STATUS_SUCCESS;
1266 }
1267
1268 VOID
1269 NTAPI
1270 CcRosReferenceCache (
1271 PFILE_OBJECT FileObject)
1272 {
1273 PROS_SHARED_CACHE_MAP SharedCacheMap;
1274 KIRQL OldIrql;
1275
1276 OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
1277 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1278 ASSERT(SharedCacheMap);
1279 ASSERT(SharedCacheMap->OpenCount != 0);
1280 SharedCacheMap->OpenCount++;
1281 KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
1282 }
1283
1284 VOID
1285 NTAPI
1286 CcRosRemoveIfClosed (
1287 PSECTION_OBJECT_POINTERS SectionObjectPointer)
1288 {
1289 PROS_SHARED_CACHE_MAP SharedCacheMap;
1290 KIRQL OldIrql;
1291
1292 DPRINT("CcRosRemoveIfClosed()\n");
1293 OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
1294 SharedCacheMap = SectionObjectPointer->SharedCacheMap;
1295 if (SharedCacheMap && SharedCacheMap->OpenCount == 0)
1296 {
1297 CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap, &OldIrql);
1298 }
1299 KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
1300 }
1301
1302
1303 VOID
1304 NTAPI
1305 CcRosDereferenceCache (
1306 PFILE_OBJECT FileObject)
1307 {
1308 PROS_SHARED_CACHE_MAP SharedCacheMap;
1309 KIRQL OldIrql;
1310
1311 OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
1312 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1313 ASSERT(SharedCacheMap);
1314 if (SharedCacheMap->OpenCount > 0)
1315 {
1316 SharedCacheMap->OpenCount--;
1317 if (SharedCacheMap->OpenCount == 0)
1318 {
1319 KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
1320 MmFreeSectionSegments(SharedCacheMap->FileObject);
1321
1322 OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
1323 CcRosDeleteFileCache(FileObject, SharedCacheMap, &OldIrql);
1324 KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
1325
1326 return;
1327 }
1328 }
1329 KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
1330 }
1331
1332 NTSTATUS
1333 NTAPI
1334 CcRosReleaseFileCache (
1335 PFILE_OBJECT FileObject)
1336 /*
1337 * FUNCTION: Called by the file system when a handle to a file object
1338 * has been closed.
1339 */
1340 {
1341 KIRQL OldIrql;
1342 PPRIVATE_CACHE_MAP PrivateMap;
1343 PROS_SHARED_CACHE_MAP SharedCacheMap;
1344
1345 OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
1346
1347 if (FileObject->SectionObjectPointer->SharedCacheMap != NULL)
1348 {
1349 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1350
1351 /* Closing the handle, so kill the private cache map
1352 * Before you event try to remove it from FO, always
1353 * lock the master lock, to be sure not to race
1354 * with a potential read ahead ongoing!
1355 */
1356 PrivateMap = FileObject->PrivateCacheMap;
1357 FileObject->PrivateCacheMap = NULL;
1358
1359 if (PrivateMap != NULL)
1360 {
1361 /* Remove it from the file */
1362 KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
1363 RemoveEntryList(&PrivateMap->PrivateLinks);
1364 KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
1365
1366 /* And free it. */
1367 if (PrivateMap != &SharedCacheMap->PrivateCacheMap)
1368 {
1369 ExFreePoolWithTag(PrivateMap, TAG_PRIVATE_CACHE_MAP);
1370 }
1371 else
1372 {
1373 PrivateMap->NodeTypeCode = 0;
1374 }
1375
1376 if (SharedCacheMap->OpenCount > 0)
1377 {
1378 SharedCacheMap->OpenCount--;
1379 if (SharedCacheMap->OpenCount == 0)
1380 {
1381 KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
1382 MmFreeSectionSegments(SharedCacheMap->FileObject);
1383
1384 OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
1385 CcRosDeleteFileCache(FileObject, SharedCacheMap, &OldIrql);
1386 KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
1387
1388 return STATUS_SUCCESS;
1389 }
1390 }
1391 }
1392 }
1393 KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
1394 return STATUS_SUCCESS;
1395 }
1396
1397 NTSTATUS
1398 NTAPI
1399 CcRosInitializeFileCache (
1400 PFILE_OBJECT FileObject,
1401 PCC_FILE_SIZES FileSizes,
1402 BOOLEAN PinAccess,
1403 PCACHE_MANAGER_CALLBACKS CallBacks,
1404 PVOID LazyWriterContext)
1405 /*
1406 * FUNCTION: Initializes a shared cache map for a file object
1407 */
1408 {
1409 KIRQL OldIrql;
1410 BOOLEAN Allocated;
1411 PROS_SHARED_CACHE_MAP SharedCacheMap;
1412
1413 DPRINT("CcRosInitializeFileCache(FileObject 0x%p)\n", FileObject);
1414
1415 Allocated = FALSE;
1416 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1417 if (SharedCacheMap == NULL)
1418 {
1419 Allocated = TRUE;
1420 SharedCacheMap = ExAllocateFromNPagedLookasideList(&SharedCacheMapLookasideList);
1421 if (SharedCacheMap == NULL)
1422 {
1423 return STATUS_INSUFFICIENT_RESOURCES;
1424 }
1425 RtlZeroMemory(SharedCacheMap, sizeof(*SharedCacheMap));
1426 SharedCacheMap->NodeTypeCode = NODE_TYPE_SHARED_MAP;
1427 SharedCacheMap->NodeByteSize = sizeof(*SharedCacheMap);
1428 SharedCacheMap->FileObject = FileObject;
1429 SharedCacheMap->Callbacks = CallBacks;
1430 SharedCacheMap->LazyWriteContext = LazyWriterContext;
1431 SharedCacheMap->SectionSize = FileSizes->AllocationSize;
1432 SharedCacheMap->FileSize = FileSizes->FileSize;
1433 SharedCacheMap->PinAccess = PinAccess;
1434 SharedCacheMap->DirtyPageThreshold = 0;
1435 SharedCacheMap->DirtyPages = 0;
1436 InitializeListHead(&SharedCacheMap->PrivateList);
1437 KeInitializeSpinLock(&SharedCacheMap->CacheMapLock);
1438 InitializeListHead(&SharedCacheMap->CacheMapVacbListHead);
1439 InitializeListHead(&SharedCacheMap->BcbList);
1440 }
1441
1442 OldIrql = KeAcquireQueuedSpinLock(LockQueueMasterLock);
1443 if (Allocated)
1444 {
1445 if (FileObject->SectionObjectPointer->SharedCacheMap == NULL)
1446 {
1447 ObReferenceObjectByPointer(FileObject,
1448 FILE_ALL_ACCESS,
1449 NULL,
1450 KernelMode);
1451 FileObject->SectionObjectPointer->SharedCacheMap = SharedCacheMap;
1452
1453 InsertTailList(&CcCleanSharedCacheMapList, &SharedCacheMap->SharedCacheMapLinks);
1454 }
1455 else
1456 {
1457 ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap);
1458 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1459 }
1460 }
1461 if (FileObject->PrivateCacheMap == NULL)
1462 {
1463 PPRIVATE_CACHE_MAP PrivateMap;
1464
1465 /* Allocate the private cache map for this handle */
1466 if (SharedCacheMap->PrivateCacheMap.NodeTypeCode != 0)
1467 {
1468 PrivateMap = ExAllocatePoolWithTag(NonPagedPool, sizeof(PRIVATE_CACHE_MAP), TAG_PRIVATE_CACHE_MAP);
1469 }
1470 else
1471 {
1472 PrivateMap = &SharedCacheMap->PrivateCacheMap;
1473 }
1474
1475 if (PrivateMap == NULL)
1476 {
1477 /* If we also allocated the shared cache map for this file, kill it */
1478 if (Allocated)
1479 {
1480 RemoveEntryList(&SharedCacheMap->SharedCacheMapLinks);
1481
1482 FileObject->SectionObjectPointer->SharedCacheMap = NULL;
1483 ObDereferenceObject(FileObject);
1484 ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap);
1485 }
1486
1487 KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
1488 return STATUS_INSUFFICIENT_RESOURCES;
1489 }
1490
1491 /* Initialize it */
1492 RtlZeroMemory(PrivateMap, sizeof(PRIVATE_CACHE_MAP));
1493 PrivateMap->NodeTypeCode = NODE_TYPE_PRIVATE_MAP;
1494 PrivateMap->ReadAheadMask = PAGE_SIZE - 1;
1495 PrivateMap->FileObject = FileObject;
1496 KeInitializeSpinLock(&PrivateMap->ReadAheadSpinLock);
1497
1498 /* Link it to the file */
1499 KeAcquireSpinLockAtDpcLevel(&SharedCacheMap->CacheMapLock);
1500 InsertTailList(&SharedCacheMap->PrivateList, &PrivateMap->PrivateLinks);
1501 KeReleaseSpinLockFromDpcLevel(&SharedCacheMap->CacheMapLock);
1502
1503 FileObject->PrivateCacheMap = PrivateMap;
1504 SharedCacheMap->OpenCount++;
1505 }
1506 KeReleaseQueuedSpinLock(LockQueueMasterLock, OldIrql);
1507
1508 return STATUS_SUCCESS;
1509 }
1510
1511 /*
1512 * @implemented
1513 */
1514 PFILE_OBJECT
1515 NTAPI
1516 CcGetFileObjectFromSectionPtrs (
1517 IN PSECTION_OBJECT_POINTERS SectionObjectPointers)
1518 {
1519 PROS_SHARED_CACHE_MAP SharedCacheMap;
1520
1521 CCTRACE(CC_API_DEBUG, "SectionObjectPointers=%p\n", SectionObjectPointers);
1522
1523 if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
1524 {
1525 SharedCacheMap = SectionObjectPointers->SharedCacheMap;
1526 ASSERT(SharedCacheMap);
1527 return SharedCacheMap->FileObject;
1528 }
1529 return NULL;
1530 }
1531
1532 VOID
1533 INIT_FUNCTION
1534 NTAPI
1535 CcInitView (
1536 VOID)
1537 {
1538 DPRINT("CcInitView()\n");
1539
1540 InitializeListHead(&DirtyVacbListHead);
1541 InitializeListHead(&VacbLruListHead);
1542 InitializeListHead(&CcDeferredWrites);
1543 InitializeListHead(&CcCleanSharedCacheMapList);
1544 KeInitializeSpinLock(&CcDeferredWriteSpinLock);
1545 ExInitializeNPagedLookasideList(&iBcbLookasideList,
1546 NULL,
1547 NULL,
1548 0,
1549 sizeof(INTERNAL_BCB),
1550 TAG_BCB,
1551 20);
1552 ExInitializeNPagedLookasideList(&SharedCacheMapLookasideList,
1553 NULL,
1554 NULL,
1555 0,
1556 sizeof(ROS_SHARED_CACHE_MAP),
1557 TAG_SHARED_CACHE_MAP,
1558 20);
1559 ExInitializeNPagedLookasideList(&VacbLookasideList,
1560 NULL,
1561 NULL,
1562 0,
1563 sizeof(ROS_VACB),
1564 TAG_VACB,
1565 20);
1566
1567 MmInitializeMemoryConsumer(MC_CACHE, CcRosTrimCache);
1568
1569 CcInitCacheZeroPage();
1570 }
1571
1572 #if DBG && defined(KDBG)
1573 BOOLEAN
1574 ExpKdbgExtFileCache(ULONG Argc, PCHAR Argv[])
1575 {
1576 PLIST_ENTRY ListEntry;
1577 UNICODE_STRING NoName = RTL_CONSTANT_STRING(L"No name for File");
1578
1579 KdbpPrint(" Usage Summary (in kb)\n");
1580 KdbpPrint("Shared\t\tValid\tDirty\tName\n");
1581 /* No need to lock the spin lock here, we're in DBG */
1582 for (ListEntry = CcCleanSharedCacheMapList.Flink;
1583 ListEntry != &CcCleanSharedCacheMapList;
1584 ListEntry = ListEntry->Flink)
1585 {
1586 PLIST_ENTRY Vacbs;
1587 ULONG Valid = 0, Dirty = 0;
1588 PROS_SHARED_CACHE_MAP SharedCacheMap;
1589 PUNICODE_STRING FileName;
1590 PWSTR Extra = L"";
1591
1592 SharedCacheMap = CONTAINING_RECORD(ListEntry, ROS_SHARED_CACHE_MAP, SharedCacheMapLinks);
1593
1594 /* Dirty size */
1595 Dirty = (SharedCacheMap->DirtyPages * PAGE_SIZE) / 1024;
1596
1597 /* First, count for all the associated VACB */
1598 for (Vacbs = SharedCacheMap->CacheMapVacbListHead.Flink;
1599 Vacbs != &SharedCacheMap->CacheMapVacbListHead;
1600 Vacbs = Vacbs->Flink)
1601 {
1602 PROS_VACB Vacb;
1603
1604 Vacb = CONTAINING_RECORD(Vacbs, ROS_VACB, CacheMapVacbListEntry);
1605 if (Vacb->Valid)
1606 {
1607 Valid += VACB_MAPPING_GRANULARITY / 1024;
1608 }
1609 }
1610
1611 /* Setup name */
1612 if (SharedCacheMap->FileObject != NULL &&
1613 SharedCacheMap->FileObject->FileName.Length != 0)
1614 {
1615 FileName = &SharedCacheMap->FileObject->FileName;
1616 }
1617 else if (SharedCacheMap->FileObject != NULL &&
1618 SharedCacheMap->FileObject->FsContext != NULL &&
1619 ((PFSRTL_COMMON_FCB_HEADER)(SharedCacheMap->FileObject->FsContext))->NodeTypeCode == 0x0502 &&
1620 ((PFSRTL_COMMON_FCB_HEADER)(SharedCacheMap->FileObject->FsContext))->NodeByteSize == 0x1F8 &&
1621 ((PUNICODE_STRING)(((PUCHAR)SharedCacheMap->FileObject->FsContext) + 0x100))->Length != 0)
1622 {
1623 FileName = (PUNICODE_STRING)(((PUCHAR)SharedCacheMap->FileObject->FsContext) + 0x100);
1624 Extra = L" (FastFAT)";
1625 }
1626 else
1627 {
1628 FileName = &NoName;
1629 }
1630
1631 /* And print */
1632 KdbpPrint("%p\t%d\t%d\t%wZ%S\n", SharedCacheMap, Valid, Dirty, FileName, Extra);
1633 }
1634
1635 return TRUE;
1636 }
1637
1638 BOOLEAN
1639 ExpKdbgExtDefWrites(ULONG Argc, PCHAR Argv[])
1640 {
1641 KdbpPrint("CcTotalDirtyPages:\t%lu (%lu Kb)\n", CcTotalDirtyPages,
1642 (CcTotalDirtyPages * PAGE_SIZE) / 1024);
1643 KdbpPrint("CcDirtyPageThreshold:\t%lu (%lu Kb)\n", CcDirtyPageThreshold,
1644 (CcDirtyPageThreshold * PAGE_SIZE) / 1024);
1645 KdbpPrint("MmAvailablePages:\t%lu (%lu Kb)\n", MmAvailablePages,
1646 (MmAvailablePages * PAGE_SIZE) / 1024);
1647 KdbpPrint("MmThrottleTop:\t\t%lu (%lu Kb)\n", MmThrottleTop,
1648 (MmThrottleTop * PAGE_SIZE) / 1024);
1649 KdbpPrint("MmThrottleBottom:\t%lu (%lu Kb)\n", MmThrottleBottom,
1650 (MmThrottleBottom * PAGE_SIZE) / 1024);
1651 KdbpPrint("MmModifiedPageListHead.Total:\t%lu (%lu Kb)\n", MmModifiedPageListHead.Total,
1652 (MmModifiedPageListHead.Total * PAGE_SIZE) / 1024);
1653
1654 if (CcTotalDirtyPages >= CcDirtyPageThreshold)
1655 {
1656 KdbpPrint("CcTotalDirtyPages above the threshold, writes should be throttled\n");
1657 }
1658 else if (CcTotalDirtyPages + 64 >= CcDirtyPageThreshold)
1659 {
1660 KdbpPrint("CcTotalDirtyPages within 64 (max charge) pages of the threshold, writes may be throttled\n");
1661 }
1662 else
1663 {
1664 KdbpPrint("CcTotalDirtyPages below the threshold, writes should not be throttled\n");
1665 }
1666
1667 return TRUE;
1668 }
1669 #endif
1670
1671 /* EOF */