[NTOSKRNL] On file cache deletion, only manipulate VACB once locked.
[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 KGUARDED_MUTEX ViewLock;
49
50 NPAGED_LOOKASIDE_LIST iBcbLookasideList;
51 static NPAGED_LOOKASIDE_LIST SharedCacheMapLookasideList;
52 static NPAGED_LOOKASIDE_LIST VacbLookasideList;
53
54 /* Counters:
55 * - Amount of pages flushed by lazy writer
56 * - Number of times lazy writer ran
57 */
58 ULONG CcLazyWritePages = 0;
59 ULONG CcLazyWriteIos = 0;
60
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
67 */
68 ULONG CcDirtyPageThreshold = 0;
69 ULONG CcTotalDirtyPages = 0;
70 LIST_ENTRY CcDeferredWrites;
71 KSPIN_LOCK CcDeferredWriteSpinLock;
72 LIST_ENTRY CcCleanSharedCacheMapList;
73
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
78 */
79 KEVENT iLazyWriterShutdown;
80 KEVENT iLazyWriterNotify;
81 KSPIN_LOCK iSharedCacheMapLock;
82
83 #if DBG
84 static void CcRosVacbIncRefCount_(PROS_VACB vacb, const char* file, int line)
85 {
86 ++vacb->ReferenceCount;
87 if (vacb->SharedCacheMap->Trace)
88 {
89 DbgPrint("(%s:%i) VACB %p ++RefCount=%lu, Dirty %u, PageOut %lu\n",
90 file, line, vacb, vacb->ReferenceCount, vacb->Dirty, vacb->PageOut);
91 }
92 }
93 static void CcRosVacbDecRefCount_(PROS_VACB vacb, const char* file, int line)
94 {
95 --vacb->ReferenceCount;
96 if (vacb->SharedCacheMap->Trace)
97 {
98 DbgPrint("(%s:%i) VACB %p --RefCount=%lu, Dirty %u, PageOut %lu\n",
99 file, line, vacb, vacb->ReferenceCount, vacb->Dirty, vacb->PageOut);
100 }
101 }
102 #define CcRosVacbIncRefCount(vacb) CcRosVacbIncRefCount_(vacb,__FILE__,__LINE__)
103 #define CcRosVacbDecRefCount(vacb) CcRosVacbDecRefCount_(vacb,__FILE__,__LINE__)
104 #else
105 #define CcRosVacbIncRefCount(vacb) (++((vacb)->ReferenceCount))
106 #define CcRosVacbDecRefCount(vacb) (--((vacb)->ReferenceCount))
107 #endif
108
109 NTSTATUS
110 CcRosInternalFreeVacb(PROS_VACB Vacb);
111
112
113 /* FUNCTIONS *****************************************************************/
114
115 VOID
116 NTAPI
117 CcRosTraceCacheMap (
118 PROS_SHARED_CACHE_MAP SharedCacheMap,
119 BOOLEAN Trace )
120 {
121 #if DBG
122 KIRQL oldirql;
123 PLIST_ENTRY current_entry;
124 PROS_VACB current;
125
126 if (!SharedCacheMap)
127 return;
128
129 SharedCacheMap->Trace = Trace;
130
131 if (Trace)
132 {
133 DPRINT1("Enabling Tracing for CacheMap 0x%p:\n", SharedCacheMap);
134
135 KeAcquireGuardedMutex(&ViewLock);
136 KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldirql);
137
138 current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
139 while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
140 {
141 current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
142 current_entry = current_entry->Flink;
143
144 DPRINT1(" VACB 0x%p enabled, RefCount %lu, Dirty %u, PageOut %lu\n",
145 current, current->ReferenceCount, current->Dirty, current->PageOut );
146 }
147 KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
148 KeReleaseGuardedMutex(&ViewLock);
149 }
150 else
151 {
152 DPRINT1("Disabling Tracing for CacheMap 0x%p:\n", SharedCacheMap);
153 }
154
155 #else
156 UNREFERENCED_PARAMETER(SharedCacheMap);
157 UNREFERENCED_PARAMETER(Trace);
158 #endif
159 }
160
161 NTSTATUS
162 NTAPI
163 CcRosFlushVacb (
164 PROS_VACB Vacb)
165 {
166 NTSTATUS Status;
167 KIRQL oldIrql;
168
169 Status = CcWriteVirtualAddress(Vacb);
170 if (NT_SUCCESS(Status))
171 {
172 KeAcquireGuardedMutex(&ViewLock);
173 KeAcquireSpinLock(&Vacb->SharedCacheMap->CacheMapLock, &oldIrql);
174
175 Vacb->Dirty = FALSE;
176 RemoveEntryList(&Vacb->DirtyVacbListEntry);
177 CcTotalDirtyPages -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
178 Vacb->SharedCacheMap->DirtyPages -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
179 CcRosVacbDecRefCount(Vacb);
180
181 KeReleaseSpinLock(&Vacb->SharedCacheMap->CacheMapLock, oldIrql);
182 KeReleaseGuardedMutex(&ViewLock);
183 }
184
185 return Status;
186 }
187
188 NTSTATUS
189 NTAPI
190 CcRosFlushDirtyPages (
191 ULONG Target,
192 PULONG Count,
193 BOOLEAN Wait,
194 BOOLEAN CalledFromLazy)
195 {
196 PLIST_ENTRY current_entry;
197 PROS_VACB current;
198 BOOLEAN Locked;
199 NTSTATUS Status;
200 LARGE_INTEGER ZeroTimeout;
201
202 DPRINT("CcRosFlushDirtyPages(Target %lu)\n", Target);
203
204 (*Count) = 0;
205 ZeroTimeout.QuadPart = 0;
206
207 KeEnterCriticalRegion();
208 KeAcquireGuardedMutex(&ViewLock);
209
210 current_entry = DirtyVacbListHead.Flink;
211 if (current_entry == &DirtyVacbListHead)
212 {
213 DPRINT("No Dirty pages\n");
214 }
215
216 while ((current_entry != &DirtyVacbListHead) && (Target > 0))
217 {
218 current = CONTAINING_RECORD(current_entry,
219 ROS_VACB,
220 DirtyVacbListEntry);
221 current_entry = current_entry->Flink;
222
223 CcRosVacbIncRefCount(current);
224
225 /* When performing lazy write, don't handle temporary files */
226 if (CalledFromLazy &&
227 BooleanFlagOn(current->SharedCacheMap->FileObject->Flags, FO_TEMPORARY_FILE))
228 {
229 CcRosVacbDecRefCount(current);
230 continue;
231 }
232
233 Locked = current->SharedCacheMap->Callbacks->AcquireForLazyWrite(
234 current->SharedCacheMap->LazyWriteContext, Wait);
235 if (!Locked)
236 {
237 CcRosVacbDecRefCount(current);
238 continue;
239 }
240
241 Status = CcRosAcquireVacbLock(current,
242 Wait ? NULL : &ZeroTimeout);
243 if (Status != STATUS_SUCCESS)
244 {
245 current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
246 current->SharedCacheMap->LazyWriteContext);
247 CcRosVacbDecRefCount(current);
248 continue;
249 }
250
251 ASSERT(current->Dirty);
252
253 /* One reference is added above */
254 if ((current->ReferenceCount > 2 && current->PinCount == 0) ||
255 (current->ReferenceCount > 3 && current->PinCount > 1))
256 {
257 CcRosReleaseVacbLock(current);
258 current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
259 current->SharedCacheMap->LazyWriteContext);
260 CcRosVacbDecRefCount(current);
261 continue;
262 }
263
264 KeReleaseGuardedMutex(&ViewLock);
265
266 Status = CcRosFlushVacb(current);
267
268 CcRosReleaseVacbLock(current);
269 current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
270 current->SharedCacheMap->LazyWriteContext);
271
272 KeAcquireGuardedMutex(&ViewLock);
273 CcRosVacbDecRefCount(current);
274
275 if (!NT_SUCCESS(Status) && (Status != STATUS_END_OF_FILE) &&
276 (Status != STATUS_MEDIA_WRITE_PROTECTED))
277 {
278 DPRINT1("CC: Failed to flush VACB.\n");
279 }
280 else
281 {
282 ULONG PagesFreed;
283
284 /* How many pages did we free? */
285 PagesFreed = VACB_MAPPING_GRANULARITY / PAGE_SIZE;
286 (*Count) += PagesFreed;
287
288 /* Make sure we don't overflow target! */
289 if (Target < PagesFreed)
290 {
291 /* If we would have, jump to zero directly */
292 Target = 0;
293 }
294 else
295 {
296 Target -= PagesFreed;
297 }
298 }
299
300 current_entry = DirtyVacbListHead.Flink;
301 }
302
303 KeReleaseGuardedMutex(&ViewLock);
304 KeLeaveCriticalRegion();
305
306 DPRINT("CcRosFlushDirtyPages() finished\n");
307 return STATUS_SUCCESS;
308 }
309
310 /* FIXME: Someday this could somewhat implement write-behind/read-ahead */
311 VOID
312 NTAPI
313 CciLazyWriter(PVOID Unused)
314 {
315 LARGE_INTEGER OneSecond;
316
317 OneSecond.QuadPart = (LONGLONG)-1*1000*1000*10;
318
319 while (TRUE)
320 {
321 NTSTATUS Status;
322 PLIST_ENTRY ListEntry;
323 ULONG Target, Count = 0;
324
325 /* One per second or until we have to stop */
326 Status = KeWaitForSingleObject(&iLazyWriterShutdown,
327 Executive,
328 KernelMode,
329 FALSE,
330 &OneSecond);
331
332 /* If we succeeed, we've to stop running! */
333 if (Status == STATUS_SUCCESS)
334 {
335 break;
336 }
337
338 /* We're not sleeping anymore */
339 KeClearEvent(&iLazyWriterNotify);
340
341 /* Our target is one-eighth of the dirty pages */
342 Target = CcTotalDirtyPages / 8;
343 if (Target != 0)
344 {
345 /* Flush! */
346 DPRINT("Lazy writer starting (%d)\n", Target);
347 CcRosFlushDirtyPages(Target, &Count, FALSE, TRUE);
348
349 /* And update stats */
350 CcLazyWritePages += Count;
351 ++CcLazyWriteIos;
352 DPRINT("Lazy writer done (%d)\n", Count);
353 }
354
355 /* Inform people waiting on us that we're done */
356 KeSetEvent(&iLazyWriterNotify, IO_DISK_INCREMENT, FALSE);
357
358 /* Likely not optimal, but let's handle one deferred write now! */
359 ListEntry = ExInterlockedRemoveHeadList(&CcDeferredWrites, &CcDeferredWriteSpinLock);
360 if (ListEntry != NULL)
361 {
362 PROS_DEFERRED_WRITE_CONTEXT Context;
363
364 /* Extract the context */
365 Context = CONTAINING_RECORD(ListEntry, ROS_DEFERRED_WRITE_CONTEXT, CcDeferredWritesEntry);
366
367 /* Can we write now? */
368 if (CcCanIWrite(Context->FileObject, Context->BytesToWrite, FALSE, Context->Retrying))
369 {
370 /* Yes! Do it, and destroy the associated context */
371 Context->PostRoutine(Context->Context1, Context->Context2);
372 ExFreePoolWithTag(Context, 'CcDw');
373 }
374 else
375 {
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!
379 */
380 ExInterlockedInsertTailList(&CcDeferredWrites,
381 &Context->CcDeferredWritesEntry,
382 &CcDeferredWriteSpinLock);
383 }
384 }
385 }
386 }
387
388 NTSTATUS
389 CcRosTrimCache (
390 ULONG Target,
391 ULONG Priority,
392 PULONG NrFreed)
393 /*
394 * FUNCTION: Try to free some memory from the file cache.
395 * ARGUMENTS:
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.
400 */
401 {
402 PLIST_ENTRY current_entry;
403 PROS_VACB current;
404 ULONG PagesFreed;
405 KIRQL oldIrql;
406 LIST_ENTRY FreeList;
407 PFN_NUMBER Page;
408 ULONG i;
409 BOOLEAN FlushedPages = FALSE;
410
411 DPRINT("CcRosTrimCache(Target %lu)\n", Target);
412
413 InitializeListHead(&FreeList);
414
415 *NrFreed = 0;
416
417 retry:
418 KeAcquireGuardedMutex(&ViewLock);
419
420 current_entry = VacbLruListHead.Flink;
421 while (current_entry != &VacbLruListHead)
422 {
423 current = CONTAINING_RECORD(current_entry,
424 ROS_VACB,
425 VacbLruListEntry);
426 current_entry = current_entry->Flink;
427
428 KeAcquireSpinLock(&current->SharedCacheMap->CacheMapLock, &oldIrql);
429
430 /* Reference the VACB */
431 CcRosVacbIncRefCount(current);
432
433 /* Check if it's mapped and not dirty */
434 if (current->MappedCount > 0 && !current->Dirty)
435 {
436 /* We have to break these locks because Cc sucks */
437 KeReleaseSpinLock(&current->SharedCacheMap->CacheMapLock, oldIrql);
438 KeReleaseGuardedMutex(&ViewLock);
439
440 /* Page out the VACB */
441 for (i = 0; i < VACB_MAPPING_GRANULARITY / PAGE_SIZE; i++)
442 {
443 Page = (PFN_NUMBER)(MmGetPhysicalAddress((PUCHAR)current->BaseAddress + (i * PAGE_SIZE)).QuadPart >> PAGE_SHIFT);
444
445 MmPageOutPhysicalAddress(Page);
446 }
447
448 /* Reacquire the locks */
449 KeAcquireGuardedMutex(&ViewLock);
450 KeAcquireSpinLock(&current->SharedCacheMap->CacheMapLock, &oldIrql);
451 }
452
453 /* Dereference the VACB */
454 CcRosVacbDecRefCount(current);
455
456 /* Check if we can free this entry now */
457 if (current->ReferenceCount == 0)
458 {
459 ASSERT(!current->Dirty);
460 ASSERT(!current->MappedCount);
461
462 RemoveEntryList(&current->CacheMapVacbListEntry);
463 RemoveEntryList(&current->VacbLruListEntry);
464 InsertHeadList(&FreeList, &current->CacheMapVacbListEntry);
465
466 /* Calculate how many pages we freed for Mm */
467 PagesFreed = min(VACB_MAPPING_GRANULARITY / PAGE_SIZE, Target);
468 Target -= PagesFreed;
469 (*NrFreed) += PagesFreed;
470 }
471
472 KeReleaseSpinLock(&current->SharedCacheMap->CacheMapLock, oldIrql);
473 }
474
475 KeReleaseGuardedMutex(&ViewLock);
476
477 /* Try flushing pages if we haven't met our target */
478 if ((Target > 0) && !FlushedPages)
479 {
480 /* Flush dirty pages to disk */
481 CcRosFlushDirtyPages(Target, &PagesFreed, FALSE, FALSE);
482 FlushedPages = TRUE;
483
484 /* We can only swap as many pages as we flushed */
485 if (PagesFreed < Target) Target = PagesFreed;
486
487 /* Check if we flushed anything */
488 if (PagesFreed != 0)
489 {
490 /* Try again after flushing dirty pages */
491 DPRINT("Flushed %lu dirty cache pages to disk\n", PagesFreed);
492 goto retry;
493 }
494 }
495
496 while (!IsListEmpty(&FreeList))
497 {
498 current_entry = RemoveHeadList(&FreeList);
499 current = CONTAINING_RECORD(current_entry,
500 ROS_VACB,
501 CacheMapVacbListEntry);
502 CcRosInternalFreeVacb(current);
503 }
504
505 DPRINT("Evicted %lu cache pages\n", (*NrFreed));
506
507 return STATUS_SUCCESS;
508 }
509
510 NTSTATUS
511 NTAPI
512 CcRosReleaseVacb (
513 PROS_SHARED_CACHE_MAP SharedCacheMap,
514 PROS_VACB Vacb,
515 BOOLEAN Valid,
516 BOOLEAN Dirty,
517 BOOLEAN Mapped)
518 {
519 BOOLEAN WasDirty;
520
521 ASSERT(SharedCacheMap);
522
523 DPRINT("CcRosReleaseVacb(SharedCacheMap 0x%p, Vacb 0x%p, Valid %u)\n",
524 SharedCacheMap, Vacb, Valid);
525
526 Vacb->Valid = Valid;
527
528 WasDirty = FALSE;
529 if (Dirty)
530 {
531 if (!Vacb->Dirty)
532 {
533 CcRosMarkDirtyVacb(Vacb);
534 }
535 else
536 {
537 WasDirty = TRUE;
538 }
539 }
540
541 if (Mapped)
542 {
543 Vacb->MappedCount++;
544 }
545 CcRosVacbDecRefCount(Vacb);
546 if (Mapped && (Vacb->MappedCount == 1))
547 {
548 CcRosVacbIncRefCount(Vacb);
549 }
550 if (!WasDirty && Vacb->Dirty)
551 {
552 CcRosVacbIncRefCount(Vacb);
553 }
554
555 CcRosReleaseVacbLock(Vacb);
556
557 return STATUS_SUCCESS;
558 }
559
560 /* Returns with VACB Lock Held! */
561 PROS_VACB
562 NTAPI
563 CcRosLookupVacb (
564 PROS_SHARED_CACHE_MAP SharedCacheMap,
565 LONGLONG FileOffset)
566 {
567 PLIST_ENTRY current_entry;
568 PROS_VACB current;
569 KIRQL oldIrql;
570
571 ASSERT(SharedCacheMap);
572
573 DPRINT("CcRosLookupVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
574 SharedCacheMap, FileOffset);
575
576 KeAcquireGuardedMutex(&ViewLock);
577 KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
578
579 current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
580 while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
581 {
582 current = CONTAINING_RECORD(current_entry,
583 ROS_VACB,
584 CacheMapVacbListEntry);
585 if (IsPointInRange(current->FileOffset.QuadPart,
586 VACB_MAPPING_GRANULARITY,
587 FileOffset))
588 {
589 CcRosVacbIncRefCount(current);
590 KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
591 KeReleaseGuardedMutex(&ViewLock);
592 CcRosAcquireVacbLock(current, NULL);
593 return current;
594 }
595 if (current->FileOffset.QuadPart > FileOffset)
596 break;
597 current_entry = current_entry->Flink;
598 }
599
600 KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
601 KeReleaseGuardedMutex(&ViewLock);
602
603 return NULL;
604 }
605
606 VOID
607 NTAPI
608 CcRosMarkDirtyVacb (
609 PROS_VACB Vacb)
610 {
611 KIRQL oldIrql;
612 PROS_SHARED_CACHE_MAP SharedCacheMap;
613
614 SharedCacheMap = Vacb->SharedCacheMap;
615
616 KeAcquireGuardedMutex(&ViewLock);
617 KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
618
619 if (!Vacb->Dirty)
620 {
621 InsertTailList(&DirtyVacbListHead, &Vacb->DirtyVacbListEntry);
622 CcTotalDirtyPages += VACB_MAPPING_GRANULARITY / PAGE_SIZE;
623 Vacb->SharedCacheMap->DirtyPages += VACB_MAPPING_GRANULARITY / PAGE_SIZE;
624 }
625 else
626 {
627 CcRosVacbDecRefCount(Vacb);
628 }
629
630 /* Move to the tail of the LRU list */
631 RemoveEntryList(&Vacb->VacbLruListEntry);
632 InsertTailList(&VacbLruListHead, &Vacb->VacbLruListEntry);
633
634 Vacb->Dirty = TRUE;
635
636 KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
637 KeReleaseGuardedMutex(&ViewLock);
638 }
639
640 NTSTATUS
641 NTAPI
642 CcRosMarkDirtyFile (
643 PROS_SHARED_CACHE_MAP SharedCacheMap,
644 LONGLONG FileOffset)
645 {
646 PROS_VACB Vacb;
647
648 ASSERT(SharedCacheMap);
649
650 DPRINT("CcRosMarkDirtyVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
651 SharedCacheMap, FileOffset);
652
653 Vacb = CcRosLookupVacb(SharedCacheMap, FileOffset);
654 if (Vacb == NULL)
655 {
656 KeBugCheck(CACHE_MANAGER);
657 }
658
659 CcRosMarkDirtyVacb(Vacb);
660
661 CcRosReleaseVacbLock(Vacb);
662
663 return STATUS_SUCCESS;
664 }
665
666 NTSTATUS
667 NTAPI
668 CcRosUnmapVacb (
669 PROS_SHARED_CACHE_MAP SharedCacheMap,
670 LONGLONG FileOffset,
671 BOOLEAN NowDirty)
672 {
673 PROS_VACB Vacb;
674 BOOLEAN WasDirty;
675
676 ASSERT(SharedCacheMap);
677
678 DPRINT("CcRosUnmapVacb(SharedCacheMap 0x%p, FileOffset %I64u, NowDirty %u)\n",
679 SharedCacheMap, FileOffset, NowDirty);
680
681 Vacb = CcRosLookupVacb(SharedCacheMap, FileOffset);
682 if (Vacb == NULL)
683 {
684 return STATUS_UNSUCCESSFUL;
685 }
686
687 WasDirty = FALSE;
688 if (NowDirty)
689 {
690 if (!Vacb->Dirty)
691 {
692 CcRosMarkDirtyVacb(Vacb);
693 }
694 else
695 {
696 WasDirty = TRUE;
697 }
698 }
699
700 Vacb->MappedCount--;
701
702 CcRosVacbDecRefCount(Vacb);
703 if (!WasDirty && NowDirty)
704 {
705 CcRosVacbIncRefCount(Vacb);
706 }
707 if (Vacb->MappedCount == 0)
708 {
709 CcRosVacbDecRefCount(Vacb);
710 }
711
712 CcRosReleaseVacbLock(Vacb);
713
714 return STATUS_SUCCESS;
715 }
716
717 static
718 NTSTATUS
719 CcRosMapVacb(
720 PROS_VACB Vacb)
721 {
722 ULONG i;
723 NTSTATUS Status;
724 ULONG_PTR NumberOfPages;
725
726 /* Create a memory area. */
727 MmLockAddressSpace(MmGetKernelAddressSpace());
728 Status = MmCreateMemoryArea(MmGetKernelAddressSpace(),
729 0, // nothing checks for VACB mareas, so set to 0
730 &Vacb->BaseAddress,
731 VACB_MAPPING_GRANULARITY,
732 PAGE_READWRITE,
733 (PMEMORY_AREA*)&Vacb->MemoryArea,
734 0,
735 PAGE_SIZE);
736 MmUnlockAddressSpace(MmGetKernelAddressSpace());
737 if (!NT_SUCCESS(Status))
738 {
739 DPRINT1("MmCreateMemoryArea failed with %lx for VACB %p\n", Status, Vacb);
740 return Status;
741 }
742
743 ASSERT(((ULONG_PTR)Vacb->BaseAddress % PAGE_SIZE) == 0);
744 ASSERT((ULONG_PTR)Vacb->BaseAddress > (ULONG_PTR)MmSystemRangeStart);
745
746 /* Create a virtual mapping for this memory area */
747 NumberOfPages = BYTES_TO_PAGES(VACB_MAPPING_GRANULARITY);
748 for (i = 0; i < NumberOfPages; i++)
749 {
750 PFN_NUMBER PageFrameNumber;
751
752 MI_SET_USAGE(MI_USAGE_CACHE);
753 Status = MmRequestPageMemoryConsumer(MC_CACHE, TRUE, &PageFrameNumber);
754 if (PageFrameNumber == 0)
755 {
756 DPRINT1("Unable to allocate page\n");
757 KeBugCheck(MEMORY_MANAGEMENT);
758 }
759
760 Status = MmCreateVirtualMapping(NULL,
761 (PVOID)((ULONG_PTR)Vacb->BaseAddress + (i * PAGE_SIZE)),
762 PAGE_READWRITE,
763 &PageFrameNumber,
764 1);
765 if (!NT_SUCCESS(Status))
766 {
767 DPRINT1("Unable to create virtual mapping\n");
768 KeBugCheck(MEMORY_MANAGEMENT);
769 }
770 }
771
772 return STATUS_SUCCESS;
773 }
774
775 static
776 NTSTATUS
777 CcRosCreateVacb (
778 PROS_SHARED_CACHE_MAP SharedCacheMap,
779 LONGLONG FileOffset,
780 PROS_VACB *Vacb)
781 {
782 PROS_VACB current;
783 PROS_VACB previous;
784 PLIST_ENTRY current_entry;
785 NTSTATUS Status;
786 KIRQL oldIrql;
787
788 ASSERT(SharedCacheMap);
789
790 DPRINT("CcRosCreateVacb()\n");
791
792 if (FileOffset >= SharedCacheMap->SectionSize.QuadPart)
793 {
794 *Vacb = NULL;
795 return STATUS_INVALID_PARAMETER;
796 }
797
798 current = ExAllocateFromNPagedLookasideList(&VacbLookasideList);
799 current->BaseAddress = NULL;
800 current->Valid = FALSE;
801 current->Dirty = FALSE;
802 current->PageOut = FALSE;
803 current->FileOffset.QuadPart = ROUND_DOWN(FileOffset, VACB_MAPPING_GRANULARITY);
804 current->SharedCacheMap = SharedCacheMap;
805 #if DBG
806 if (SharedCacheMap->Trace)
807 {
808 DPRINT1("CacheMap 0x%p: new VACB: 0x%p\n", SharedCacheMap, current);
809 }
810 #endif
811 current->MappedCount = 0;
812 current->DirtyVacbListEntry.Flink = NULL;
813 current->DirtyVacbListEntry.Blink = NULL;
814 current->ReferenceCount = 1;
815 current->PinCount = 0;
816 KeInitializeMutex(&current->Mutex, 0);
817 CcRosAcquireVacbLock(current, NULL);
818 KeAcquireGuardedMutex(&ViewLock);
819
820 *Vacb = current;
821 /* There is window between the call to CcRosLookupVacb
822 * and CcRosCreateVacb. We must check if a VACB for the
823 * file offset exist. If there is a VACB, we release
824 * our newly created VACB and return the existing one.
825 */
826 KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
827 current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
828 previous = NULL;
829 while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
830 {
831 current = CONTAINING_RECORD(current_entry,
832 ROS_VACB,
833 CacheMapVacbListEntry);
834 if (IsPointInRange(current->FileOffset.QuadPart,
835 VACB_MAPPING_GRANULARITY,
836 FileOffset))
837 {
838 CcRosVacbIncRefCount(current);
839 KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
840 #if DBG
841 if (SharedCacheMap->Trace)
842 {
843 DPRINT1("CacheMap 0x%p: deleting newly created VACB 0x%p ( found existing one 0x%p )\n",
844 SharedCacheMap,
845 (*Vacb),
846 current);
847 }
848 #endif
849 CcRosReleaseVacbLock(*Vacb);
850 KeReleaseGuardedMutex(&ViewLock);
851 ExFreeToNPagedLookasideList(&VacbLookasideList, *Vacb);
852 *Vacb = current;
853 CcRosAcquireVacbLock(current, NULL);
854 return STATUS_SUCCESS;
855 }
856 if (current->FileOffset.QuadPart < FileOffset)
857 {
858 ASSERT(previous == NULL ||
859 previous->FileOffset.QuadPart < current->FileOffset.QuadPart);
860 previous = current;
861 }
862 if (current->FileOffset.QuadPart > FileOffset)
863 break;
864 current_entry = current_entry->Flink;
865 }
866 /* There was no existing VACB. */
867 current = *Vacb;
868 if (previous)
869 {
870 InsertHeadList(&previous->CacheMapVacbListEntry, &current->CacheMapVacbListEntry);
871 }
872 else
873 {
874 InsertHeadList(&SharedCacheMap->CacheMapVacbListHead, &current->CacheMapVacbListEntry);
875 }
876 KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
877 InsertTailList(&VacbLruListHead, &current->VacbLruListEntry);
878 KeReleaseGuardedMutex(&ViewLock);
879
880 MI_SET_USAGE(MI_USAGE_CACHE);
881 #if MI_TRACE_PFNS
882 if ((SharedCacheMap->FileObject) && (SharedCacheMap->FileObject->FileName.Buffer))
883 {
884 PWCHAR pos;
885 ULONG len = 0;
886 pos = wcsrchr(SharedCacheMap->FileObject->FileName.Buffer, '\\');
887 if (pos)
888 {
889 len = wcslen(pos) * sizeof(WCHAR);
890 snprintf(MI_PFN_CURRENT_PROCESS_NAME, min(16, len), "%S", pos);
891 }
892 else
893 {
894 snprintf(MI_PFN_CURRENT_PROCESS_NAME, min(16, len), "%wZ", &SharedCacheMap->FileObject->FileName);
895 }
896 }
897 #endif
898
899 Status = CcRosMapVacb(current);
900 if (!NT_SUCCESS(Status))
901 {
902 RemoveEntryList(&current->CacheMapVacbListEntry);
903 RemoveEntryList(&current->VacbLruListEntry);
904 CcRosReleaseVacbLock(current);
905 ExFreeToNPagedLookasideList(&VacbLookasideList, current);
906 }
907
908 return Status;
909 }
910
911 NTSTATUS
912 NTAPI
913 CcRosGetVacb (
914 PROS_SHARED_CACHE_MAP SharedCacheMap,
915 LONGLONG FileOffset,
916 PLONGLONG BaseOffset,
917 PVOID* BaseAddress,
918 PBOOLEAN UptoDate,
919 PROS_VACB *Vacb)
920 {
921 PROS_VACB current;
922 NTSTATUS Status;
923
924 ASSERT(SharedCacheMap);
925
926 DPRINT("CcRosGetVacb()\n");
927
928 /*
929 * Look for a VACB already mapping the same data.
930 */
931 current = CcRosLookupVacb(SharedCacheMap, FileOffset);
932 if (current == NULL)
933 {
934 /*
935 * Otherwise create a new VACB.
936 */
937 Status = CcRosCreateVacb(SharedCacheMap, FileOffset, &current);
938 if (!NT_SUCCESS(Status))
939 {
940 return Status;
941 }
942 }
943
944 KeAcquireGuardedMutex(&ViewLock);
945
946 /* Move to the tail of the LRU list */
947 RemoveEntryList(&current->VacbLruListEntry);
948 InsertTailList(&VacbLruListHead, &current->VacbLruListEntry);
949
950 KeReleaseGuardedMutex(&ViewLock);
951
952 /*
953 * Return information about the VACB to the caller.
954 */
955 *UptoDate = current->Valid;
956 *BaseAddress = current->BaseAddress;
957 DPRINT("*BaseAddress %p\n", *BaseAddress);
958 *Vacb = current;
959 *BaseOffset = current->FileOffset.QuadPart;
960 return STATUS_SUCCESS;
961 }
962
963 NTSTATUS
964 NTAPI
965 CcRosRequestVacb (
966 PROS_SHARED_CACHE_MAP SharedCacheMap,
967 LONGLONG FileOffset,
968 PVOID* BaseAddress,
969 PBOOLEAN UptoDate,
970 PROS_VACB *Vacb)
971 /*
972 * FUNCTION: Request a page mapping for a shared cache map
973 */
974 {
975 LONGLONG BaseOffset;
976
977 ASSERT(SharedCacheMap);
978
979 if (FileOffset % VACB_MAPPING_GRANULARITY != 0)
980 {
981 DPRINT1("Bad fileoffset %I64x should be multiple of %x",
982 FileOffset, VACB_MAPPING_GRANULARITY);
983 KeBugCheck(CACHE_MANAGER);
984 }
985
986 return CcRosGetVacb(SharedCacheMap,
987 FileOffset,
988 &BaseOffset,
989 BaseAddress,
990 UptoDate,
991 Vacb);
992 }
993
994 static
995 VOID
996 CcFreeCachePage (
997 PVOID Context,
998 MEMORY_AREA* MemoryArea,
999 PVOID Address,
1000 PFN_NUMBER Page,
1001 SWAPENTRY SwapEntry,
1002 BOOLEAN Dirty)
1003 {
1004 ASSERT(SwapEntry == 0);
1005 if (Page != 0)
1006 {
1007 ASSERT(MmGetReferenceCountPage(Page) == 1);
1008 MmReleasePageMemoryConsumer(MC_CACHE, Page);
1009 }
1010 }
1011
1012 NTSTATUS
1013 CcRosInternalFreeVacb (
1014 PROS_VACB Vacb)
1015 /*
1016 * FUNCTION: Releases a VACB associated with a shared cache map
1017 */
1018 {
1019 DPRINT("Freeing VACB 0x%p\n", Vacb);
1020 #if DBG
1021 if (Vacb->SharedCacheMap->Trace)
1022 {
1023 DPRINT1("CacheMap 0x%p: deleting VACB: 0x%p\n", Vacb->SharedCacheMap, Vacb);
1024 }
1025 #endif
1026
1027 MmLockAddressSpace(MmGetKernelAddressSpace());
1028 MmFreeMemoryArea(MmGetKernelAddressSpace(),
1029 Vacb->MemoryArea,
1030 CcFreeCachePage,
1031 NULL);
1032 MmUnlockAddressSpace(MmGetKernelAddressSpace());
1033
1034 ExFreeToNPagedLookasideList(&VacbLookasideList, Vacb);
1035 return STATUS_SUCCESS;
1036 }
1037
1038 /*
1039 * @implemented
1040 */
1041 VOID
1042 NTAPI
1043 CcFlushCache (
1044 IN PSECTION_OBJECT_POINTERS SectionObjectPointers,
1045 IN PLARGE_INTEGER FileOffset OPTIONAL,
1046 IN ULONG Length,
1047 OUT PIO_STATUS_BLOCK IoStatus)
1048 {
1049 PROS_SHARED_CACHE_MAP SharedCacheMap;
1050 LARGE_INTEGER Offset;
1051 LONGLONG RemainingLength;
1052 PROS_VACB current;
1053 NTSTATUS Status;
1054 KIRQL oldIrql;
1055
1056 CCTRACE(CC_API_DEBUG, "SectionObjectPointers=%p FileOffset=%p Length=%lu\n",
1057 SectionObjectPointers, FileOffset, Length);
1058
1059 DPRINT("CcFlushCache(SectionObjectPointers 0x%p, FileOffset 0x%p, Length %lu, IoStatus 0x%p)\n",
1060 SectionObjectPointers, FileOffset, Length, IoStatus);
1061
1062 if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
1063 {
1064 SharedCacheMap = SectionObjectPointers->SharedCacheMap;
1065 ASSERT(SharedCacheMap);
1066 if (FileOffset)
1067 {
1068 Offset = *FileOffset;
1069 RemainingLength = Length;
1070 }
1071 else
1072 {
1073 Offset.QuadPart = 0;
1074 RemainingLength = SharedCacheMap->FileSize.QuadPart;
1075 }
1076
1077 if (IoStatus)
1078 {
1079 IoStatus->Status = STATUS_SUCCESS;
1080 IoStatus->Information = 0;
1081 }
1082
1083 while (RemainingLength > 0)
1084 {
1085 current = CcRosLookupVacb(SharedCacheMap, Offset.QuadPart);
1086 if (current != NULL)
1087 {
1088 if (current->Dirty)
1089 {
1090 Status = CcRosFlushVacb(current);
1091 if (!NT_SUCCESS(Status) && IoStatus != NULL)
1092 {
1093 IoStatus->Status = Status;
1094 }
1095 }
1096
1097 CcRosReleaseVacbLock(current);
1098
1099 KeAcquireGuardedMutex(&ViewLock);
1100 KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
1101 CcRosVacbDecRefCount(current);
1102 KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
1103 KeReleaseGuardedMutex(&ViewLock);
1104 }
1105
1106 Offset.QuadPart += VACB_MAPPING_GRANULARITY;
1107 RemainingLength -= min(RemainingLength, VACB_MAPPING_GRANULARITY);
1108 }
1109 }
1110 else
1111 {
1112 if (IoStatus)
1113 {
1114 IoStatus->Status = STATUS_INVALID_PARAMETER;
1115 }
1116 }
1117 }
1118
1119 NTSTATUS
1120 NTAPI
1121 CcRosDeleteFileCache (
1122 PFILE_OBJECT FileObject,
1123 PROS_SHARED_CACHE_MAP SharedCacheMap)
1124 /*
1125 * FUNCTION: Releases the shared cache map associated with a file object
1126 */
1127 {
1128 PLIST_ENTRY current_entry;
1129 PROS_VACB current;
1130 LIST_ENTRY FreeList;
1131 KIRQL oldIrql;
1132
1133 ASSERT(SharedCacheMap);
1134
1135 SharedCacheMap->OpenCount++;
1136 KeReleaseGuardedMutex(&ViewLock);
1137
1138 CcFlushCache(FileObject->SectionObjectPointer, NULL, 0, NULL);
1139
1140 KeAcquireGuardedMutex(&ViewLock);
1141 SharedCacheMap->OpenCount--;
1142 if (SharedCacheMap->OpenCount == 0)
1143 {
1144 KIRQL OldIrql;
1145
1146 FileObject->SectionObjectPointer->SharedCacheMap = NULL;
1147
1148 /*
1149 * Release all VACBs
1150 */
1151 InitializeListHead(&FreeList);
1152 KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
1153 while (!IsListEmpty(&SharedCacheMap->CacheMapVacbListHead))
1154 {
1155 current_entry = RemoveTailList(&SharedCacheMap->CacheMapVacbListHead);
1156 KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
1157
1158 current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
1159 CcRosAcquireVacbLock(current, NULL);
1160 RemoveEntryList(&current->VacbLruListEntry);
1161 if (current->Dirty)
1162 {
1163 RemoveEntryList(&current->DirtyVacbListEntry);
1164 CcTotalDirtyPages -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
1165 current->SharedCacheMap->DirtyPages -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
1166 DPRINT1("Freeing dirty VACB\n");
1167 }
1168 InsertHeadList(&FreeList, &current->CacheMapVacbListEntry);
1169 CcRosReleaseVacbLock(current);
1170
1171 KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
1172 }
1173 #if DBG
1174 SharedCacheMap->Trace = FALSE;
1175 #endif
1176 KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
1177
1178 KeReleaseGuardedMutex(&ViewLock);
1179 ObDereferenceObject(SharedCacheMap->FileObject);
1180
1181 while (!IsListEmpty(&FreeList))
1182 {
1183 current_entry = RemoveTailList(&FreeList);
1184 current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
1185 CcRosInternalFreeVacb(current);
1186 }
1187
1188 KeAcquireSpinLock(&iSharedCacheMapLock, &OldIrql);
1189 RemoveEntryList(&SharedCacheMap->SharedCacheMapLinks);
1190 KeReleaseSpinLock(&iSharedCacheMapLock, OldIrql);
1191
1192 ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap);
1193 KeAcquireGuardedMutex(&ViewLock);
1194 }
1195 return STATUS_SUCCESS;
1196 }
1197
1198 VOID
1199 NTAPI
1200 CcRosReferenceCache (
1201 PFILE_OBJECT FileObject)
1202 {
1203 PROS_SHARED_CACHE_MAP SharedCacheMap;
1204 KeAcquireGuardedMutex(&ViewLock);
1205 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1206 ASSERT(SharedCacheMap);
1207 ASSERT(SharedCacheMap->OpenCount != 0);
1208 SharedCacheMap->OpenCount++;
1209 KeReleaseGuardedMutex(&ViewLock);
1210 }
1211
1212 VOID
1213 NTAPI
1214 CcRosRemoveIfClosed (
1215 PSECTION_OBJECT_POINTERS SectionObjectPointer)
1216 {
1217 PROS_SHARED_CACHE_MAP SharedCacheMap;
1218 DPRINT("CcRosRemoveIfClosed()\n");
1219 KeAcquireGuardedMutex(&ViewLock);
1220 SharedCacheMap = SectionObjectPointer->SharedCacheMap;
1221 if (SharedCacheMap && SharedCacheMap->OpenCount == 0)
1222 {
1223 CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap);
1224 }
1225 KeReleaseGuardedMutex(&ViewLock);
1226 }
1227
1228
1229 VOID
1230 NTAPI
1231 CcRosDereferenceCache (
1232 PFILE_OBJECT FileObject)
1233 {
1234 PROS_SHARED_CACHE_MAP SharedCacheMap;
1235 KeAcquireGuardedMutex(&ViewLock);
1236 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1237 ASSERT(SharedCacheMap);
1238 if (SharedCacheMap->OpenCount > 0)
1239 {
1240 SharedCacheMap->OpenCount--;
1241 if (SharedCacheMap->OpenCount == 0)
1242 {
1243 MmFreeSectionSegments(SharedCacheMap->FileObject);
1244 CcRosDeleteFileCache(FileObject, SharedCacheMap);
1245 }
1246 }
1247 KeReleaseGuardedMutex(&ViewLock);
1248 }
1249
1250 NTSTATUS
1251 NTAPI
1252 CcRosReleaseFileCache (
1253 PFILE_OBJECT FileObject)
1254 /*
1255 * FUNCTION: Called by the file system when a handle to a file object
1256 * has been closed.
1257 */
1258 {
1259 PROS_SHARED_CACHE_MAP SharedCacheMap;
1260
1261 KeAcquireGuardedMutex(&ViewLock);
1262
1263 if (FileObject->SectionObjectPointer->SharedCacheMap != NULL)
1264 {
1265 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1266 if (FileObject->PrivateCacheMap != NULL)
1267 {
1268 FileObject->PrivateCacheMap = NULL;
1269 if (SharedCacheMap->OpenCount > 0)
1270 {
1271 SharedCacheMap->OpenCount--;
1272 if (SharedCacheMap->OpenCount == 0)
1273 {
1274 MmFreeSectionSegments(SharedCacheMap->FileObject);
1275 CcRosDeleteFileCache(FileObject, SharedCacheMap);
1276 }
1277 }
1278 }
1279 }
1280 KeReleaseGuardedMutex(&ViewLock);
1281 return STATUS_SUCCESS;
1282 }
1283
1284 NTSTATUS
1285 NTAPI
1286 CcTryToInitializeFileCache (
1287 PFILE_OBJECT FileObject)
1288 {
1289 PROS_SHARED_CACHE_MAP SharedCacheMap;
1290 NTSTATUS Status;
1291
1292 KeAcquireGuardedMutex(&ViewLock);
1293
1294 ASSERT(FileObject->SectionObjectPointer);
1295 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1296 if (SharedCacheMap == NULL)
1297 {
1298 Status = STATUS_UNSUCCESSFUL;
1299 }
1300 else
1301 {
1302 if (FileObject->PrivateCacheMap == NULL)
1303 {
1304 FileObject->PrivateCacheMap = SharedCacheMap;
1305 SharedCacheMap->OpenCount++;
1306 }
1307 Status = STATUS_SUCCESS;
1308 }
1309 KeReleaseGuardedMutex(&ViewLock);
1310
1311 return Status;
1312 }
1313
1314
1315 NTSTATUS
1316 NTAPI
1317 CcRosInitializeFileCache (
1318 PFILE_OBJECT FileObject,
1319 PCC_FILE_SIZES FileSizes,
1320 BOOLEAN PinAccess,
1321 PCACHE_MANAGER_CALLBACKS CallBacks,
1322 PVOID LazyWriterContext)
1323 /*
1324 * FUNCTION: Initializes a shared cache map for a file object
1325 */
1326 {
1327 PROS_SHARED_CACHE_MAP SharedCacheMap;
1328
1329 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1330 DPRINT("CcRosInitializeFileCache(FileObject 0x%p, SharedCacheMap 0x%p)\n",
1331 FileObject, SharedCacheMap);
1332
1333 KeAcquireGuardedMutex(&ViewLock);
1334 if (SharedCacheMap == NULL)
1335 {
1336 KIRQL OldIrql;
1337
1338 SharedCacheMap = ExAllocateFromNPagedLookasideList(&SharedCacheMapLookasideList);
1339 if (SharedCacheMap == NULL)
1340 {
1341 KeReleaseGuardedMutex(&ViewLock);
1342 return STATUS_INSUFFICIENT_RESOURCES;
1343 }
1344 RtlZeroMemory(SharedCacheMap, sizeof(*SharedCacheMap));
1345 ObReferenceObjectByPointer(FileObject,
1346 FILE_ALL_ACCESS,
1347 NULL,
1348 KernelMode);
1349 SharedCacheMap->FileObject = FileObject;
1350 SharedCacheMap->Callbacks = CallBacks;
1351 SharedCacheMap->LazyWriteContext = LazyWriterContext;
1352 SharedCacheMap->SectionSize = FileSizes->AllocationSize;
1353 SharedCacheMap->FileSize = FileSizes->FileSize;
1354 SharedCacheMap->PinAccess = PinAccess;
1355 SharedCacheMap->DirtyPageThreshold = 0;
1356 SharedCacheMap->DirtyPages = 0;
1357 KeInitializeSpinLock(&SharedCacheMap->CacheMapLock);
1358 InitializeListHead(&SharedCacheMap->CacheMapVacbListHead);
1359 FileObject->SectionObjectPointer->SharedCacheMap = SharedCacheMap;
1360
1361 KeAcquireSpinLock(&iSharedCacheMapLock, &OldIrql);
1362 InsertTailList(&CcCleanSharedCacheMapList, &SharedCacheMap->SharedCacheMapLinks);
1363 KeReleaseSpinLock(&iSharedCacheMapLock, OldIrql);
1364 }
1365 if (FileObject->PrivateCacheMap == NULL)
1366 {
1367 FileObject->PrivateCacheMap = SharedCacheMap;
1368 SharedCacheMap->OpenCount++;
1369 }
1370 KeReleaseGuardedMutex(&ViewLock);
1371
1372 return STATUS_SUCCESS;
1373 }
1374
1375 /*
1376 * @implemented
1377 */
1378 PFILE_OBJECT
1379 NTAPI
1380 CcGetFileObjectFromSectionPtrs (
1381 IN PSECTION_OBJECT_POINTERS SectionObjectPointers)
1382 {
1383 PROS_SHARED_CACHE_MAP SharedCacheMap;
1384
1385 CCTRACE(CC_API_DEBUG, "SectionObjectPointers=%p\n", SectionObjectPointers);
1386
1387 if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
1388 {
1389 SharedCacheMap = SectionObjectPointers->SharedCacheMap;
1390 ASSERT(SharedCacheMap);
1391 return SharedCacheMap->FileObject;
1392 }
1393 return NULL;
1394 }
1395
1396 VOID
1397 NTAPI
1398 CcShutdownLazyWriter (
1399 VOID)
1400 {
1401 /* Simply set the event, lazy writer will stop when it's done */
1402 KeSetEvent(&iLazyWriterShutdown, IO_DISK_INCREMENT, FALSE);
1403 }
1404
1405 BOOLEAN
1406 INIT_FUNCTION
1407 NTAPI
1408 CcInitView (
1409 VOID)
1410 {
1411 HANDLE LazyWriter;
1412 NTSTATUS Status;
1413 KPRIORITY Priority;
1414 OBJECT_ATTRIBUTES ObjectAttributes;
1415
1416 DPRINT("CcInitView()\n");
1417
1418 InitializeListHead(&DirtyVacbListHead);
1419 InitializeListHead(&VacbLruListHead);
1420 InitializeListHead(&CcDeferredWrites);
1421 InitializeListHead(&CcCleanSharedCacheMapList);
1422 KeInitializeSpinLock(&CcDeferredWriteSpinLock);
1423 KeInitializeSpinLock(&iSharedCacheMapLock);
1424 KeInitializeGuardedMutex(&ViewLock);
1425 ExInitializeNPagedLookasideList(&iBcbLookasideList,
1426 NULL,
1427 NULL,
1428 0,
1429 sizeof(INTERNAL_BCB),
1430 TAG_BCB,
1431 20);
1432 ExInitializeNPagedLookasideList(&SharedCacheMapLookasideList,
1433 NULL,
1434 NULL,
1435 0,
1436 sizeof(ROS_SHARED_CACHE_MAP),
1437 TAG_SHARED_CACHE_MAP,
1438 20);
1439 ExInitializeNPagedLookasideList(&VacbLookasideList,
1440 NULL,
1441 NULL,
1442 0,
1443 sizeof(ROS_VACB),
1444 TAG_VACB,
1445 20);
1446
1447 MmInitializeMemoryConsumer(MC_CACHE, CcRosTrimCache);
1448
1449 /* Initialize lazy writer events */
1450 KeInitializeEvent(&iLazyWriterShutdown, SynchronizationEvent, FALSE);
1451 KeInitializeEvent(&iLazyWriterNotify, NotificationEvent, FALSE);
1452
1453 /* Define lazy writer threshold, depending on system type */
1454 switch (MmQuerySystemSize())
1455 {
1456 case MmSmallSystem:
1457 CcDirtyPageThreshold = MmNumberOfPhysicalPages / 8;
1458 break;
1459
1460 case MmMediumSystem:
1461 CcDirtyPageThreshold = MmNumberOfPhysicalPages / 4;
1462 break;
1463
1464 case MmLargeSystem:
1465 CcDirtyPageThreshold = MmNumberOfPhysicalPages / 8 + MmNumberOfPhysicalPages / 4;
1466 break;
1467 }
1468
1469 /* Start the lazy writer thread */
1470 InitializeObjectAttributes(&ObjectAttributes,
1471 NULL,
1472 OBJ_KERNEL_HANDLE,
1473 NULL,
1474 NULL);
1475 Status = PsCreateSystemThread(&LazyWriter,
1476 THREAD_ALL_ACCESS,
1477 &ObjectAttributes,
1478 NULL,
1479 NULL,
1480 CciLazyWriter,
1481 NULL);
1482 if (!NT_SUCCESS(Status))
1483 {
1484 return FALSE;
1485 }
1486
1487 Priority = 27;
1488 Status = NtSetInformationThread(LazyWriter,
1489 ThreadPriority,
1490 &Priority,
1491 sizeof(Priority));
1492 ASSERT(NT_SUCCESS(Status));
1493
1494 /* Handle is not needed */
1495 ObCloseHandle(LazyWriter, KernelMode);
1496
1497 CcInitCacheZeroPage();
1498
1499 return TRUE;
1500 }
1501
1502 #if DBG && defined(KDBG)
1503 BOOLEAN
1504 ExpKdbgExtFileCache(ULONG Argc, PCHAR Argv[])
1505 {
1506 PLIST_ENTRY ListEntry;
1507 UNICODE_STRING NoName = RTL_CONSTANT_STRING(L"No name for File");
1508
1509 KdbpPrint(" Usage Summary (in kb)\n");
1510 KdbpPrint("Shared\t\tValid\tDirty\tName\n");
1511 /* No need to lock the spin lock here, we're in DBG */
1512 for (ListEntry = CcCleanSharedCacheMapList.Flink;
1513 ListEntry != &CcCleanSharedCacheMapList;
1514 ListEntry = ListEntry->Flink)
1515 {
1516 PLIST_ENTRY Vacbs;
1517 ULONG Valid = 0, Dirty = 0;
1518 PROS_SHARED_CACHE_MAP SharedCacheMap;
1519 PUNICODE_STRING FileName;
1520
1521 SharedCacheMap = CONTAINING_RECORD(ListEntry, ROS_SHARED_CACHE_MAP, SharedCacheMapLinks);
1522
1523 /* Dirty size */
1524 Dirty = (SharedCacheMap->DirtyPages * PAGE_SIZE) / 1024;
1525
1526 /* First, count for all the associated VACB */
1527 for (Vacbs = SharedCacheMap->CacheMapVacbListHead.Flink;
1528 Vacbs != &SharedCacheMap->CacheMapVacbListHead;
1529 Vacbs = Vacbs->Flink)
1530 {
1531 PROS_VACB Vacb;
1532
1533 Vacb = CONTAINING_RECORD(Vacbs, ROS_VACB, CacheMapVacbListEntry);
1534 if (Vacb->Valid)
1535 {
1536 Valid += VACB_MAPPING_GRANULARITY / 1024;
1537 }
1538 }
1539
1540 /* Setup name */
1541 if (SharedCacheMap->FileObject != NULL &&
1542 SharedCacheMap->FileObject->FileName.Length != 0)
1543 {
1544 FileName = &SharedCacheMap->FileObject->FileName;
1545 }
1546 else
1547 {
1548 FileName = &NoName;
1549 }
1550
1551 /* And print */
1552 KdbpPrint("%p\t%d\t%d\t%wZ\n", SharedCacheMap, Valid, Dirty, FileName);
1553 }
1554
1555 return TRUE;
1556 }
1557 #endif
1558
1559 /* EOF */