/* GLOBALS *******************************************************************/
static LIST_ENTRY DirtyVacbListHead;
-static LIST_ENTRY VacbListHead;
static LIST_ENTRY VacbLruListHead;
-static LIST_ENTRY ClosedListHead;
ULONG DirtyPageCount = 0;
KGUARDED_MUTEX ViewLock;
NPAGED_LOOKASIDE_LIST iBcbLookasideList;
-static NPAGED_LOOKASIDE_LIST BcbLookasideList;
+static NPAGED_LOOKASIDE_LIST SharedCacheMapLookasideList;
static NPAGED_LOOKASIDE_LIST VacbLookasideList;
#if DBG
static void CcRosVacbIncRefCount_(PROS_VACB vacb, const char* file, int line)
{
++vacb->ReferenceCount;
- if (vacb->Bcb->Trace)
+ if (vacb->SharedCacheMap->Trace)
{
DbgPrint("(%s:%i) VACB %p ++RefCount=%lu, Dirty %u, PageOut %lu\n",
file, line, vacb, vacb->ReferenceCount, vacb->Dirty, vacb->PageOut);
static void CcRosVacbDecRefCount_(PROS_VACB vacb, const char* file, int line)
{
--vacb->ReferenceCount;
- if (vacb->Bcb->Trace)
+ if (vacb->SharedCacheMap->Trace)
{
DbgPrint("(%s:%i) VACB %p --RefCount=%lu, Dirty %u, PageOut %lu\n",
file, line, vacb, vacb->ReferenceCount, vacb->Dirty, vacb->PageOut);
VOID
NTAPI
CcRosTraceCacheMap (
- PBCB Bcb,
+ PROS_SHARED_CACHE_MAP SharedCacheMap,
BOOLEAN Trace )
{
#if DBG
PLIST_ENTRY current_entry;
PROS_VACB current;
- if ( !Bcb )
+ if (!SharedCacheMap)
return;
- Bcb->Trace = Trace;
+ SharedCacheMap->Trace = Trace;
- if ( Trace )
+ if (Trace)
{
- DPRINT1("Enabling Tracing for CacheMap 0x%p:\n", Bcb );
+ DPRINT1("Enabling Tracing for CacheMap 0x%p:\n", SharedCacheMap);
KeAcquireGuardedMutex(&ViewLock);
- KeAcquireSpinLock(&Bcb->BcbLock, &oldirql);
+ KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldirql);
- current_entry = Bcb->BcbVacbListHead.Flink;
- while (current_entry != &Bcb->BcbVacbListHead)
+ current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
+ while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
{
- current = CONTAINING_RECORD(current_entry, ROS_VACB, BcbVacbListEntry);
+ current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
current_entry = current_entry->Flink;
DPRINT1(" VACB 0x%p enabled, RefCount %lu, Dirty %u, PageOut %lu\n",
current, current->ReferenceCount, current->Dirty, current->PageOut );
}
- KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
+ KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
KeReleaseGuardedMutex(&ViewLock);
}
else
{
- DPRINT1("Disabling Tracing for CacheMap 0x%p:\n", Bcb );
+ DPRINT1("Disabling Tracing for CacheMap 0x%p:\n", SharedCacheMap);
}
#else
- Bcb = Bcb;
- Trace = Trace;
+ UNREFERENCED_PARAMETER(SharedCacheMap);
+ UNREFERENCED_PARAMETER(Trace);
#endif
}
if (NT_SUCCESS(Status))
{
KeAcquireGuardedMutex(&ViewLock);
- KeAcquireSpinLock(&Vacb->Bcb->BcbLock, &oldIrql);
+ KeAcquireSpinLock(&Vacb->SharedCacheMap->CacheMapLock, &oldIrql);
Vacb->Dirty = FALSE;
RemoveEntryList(&Vacb->DirtyVacbListEntry);
DirtyPageCount -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
CcRosVacbDecRefCount(Vacb);
- KeReleaseSpinLock(&Vacb->Bcb->BcbLock, oldIrql);
+ KeReleaseSpinLock(&Vacb->SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock);
}
CcRosVacbIncRefCount(current);
- Locked = current->Bcb->Callbacks->AcquireForLazyWrite(
- current->Bcb->LazyWriteContext, Wait);
+ Locked = current->SharedCacheMap->Callbacks->AcquireForLazyWrite(
+ current->SharedCacheMap->LazyWriteContext, Wait);
if (!Locked)
{
CcRosVacbDecRefCount(current);
Wait ? NULL : &ZeroTimeout);
if (Status != STATUS_SUCCESS)
{
- current->Bcb->Callbacks->ReleaseFromLazyWrite(
- current->Bcb->LazyWriteContext);
+ current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
+ current->SharedCacheMap->LazyWriteContext);
CcRosVacbDecRefCount(current);
continue;
}
if (current->ReferenceCount > 2)
{
KeReleaseMutex(¤t->Mutex, FALSE);
- current->Bcb->Callbacks->ReleaseFromLazyWrite(
- current->Bcb->LazyWriteContext);
+ current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
+ current->SharedCacheMap->LazyWriteContext);
CcRosVacbDecRefCount(current);
continue;
}
Status = CcRosFlushVacb(current);
KeReleaseMutex(¤t->Mutex, FALSE);
- current->Bcb->Callbacks->ReleaseFromLazyWrite(
- current->Bcb->LazyWriteContext);
+ current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
+ current->SharedCacheMap->LazyWriteContext);
KeAcquireGuardedMutex(&ViewLock);
CcRosVacbDecRefCount(current);
VacbLruListEntry);
current_entry = current_entry->Flink;
- KeAcquireSpinLock(¤t->Bcb->BcbLock, &oldIrql);
+ KeAcquireSpinLock(¤t->SharedCacheMap->CacheMapLock, &oldIrql);
/* Reference the VACB */
CcRosVacbIncRefCount(current);
if (current->MappedCount > 0 && !current->Dirty)
{
/* We have to break these locks because Cc sucks */
- KeReleaseSpinLock(¤t->Bcb->BcbLock, oldIrql);
+ KeReleaseSpinLock(¤t->SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock);
/* Page out the VACB */
/* Reacquire the locks */
KeAcquireGuardedMutex(&ViewLock);
- KeAcquireSpinLock(¤t->Bcb->BcbLock, &oldIrql);
+ KeAcquireSpinLock(¤t->SharedCacheMap->CacheMapLock, &oldIrql);
}
/* Dereference the VACB */
ASSERT(!current->Dirty);
ASSERT(!current->MappedCount);
- RemoveEntryList(¤t->BcbVacbListEntry);
- RemoveEntryList(¤t->VacbListEntry);
+ RemoveEntryList(¤t->CacheMapVacbListEntry);
RemoveEntryList(¤t->VacbLruListEntry);
- InsertHeadList(&FreeList, ¤t->BcbVacbListEntry);
+ InsertHeadList(&FreeList, ¤t->CacheMapVacbListEntry);
/* Calculate how many pages we freed for Mm */
PagesFreed = min(VACB_MAPPING_GRANULARITY / PAGE_SIZE, Target);
(*NrFreed) += PagesFreed;
}
- KeReleaseSpinLock(¤t->Bcb->BcbLock, oldIrql);
+ KeReleaseSpinLock(¤t->SharedCacheMap->CacheMapLock, oldIrql);
}
KeReleaseGuardedMutex(&ViewLock);
current_entry = RemoveHeadList(&FreeList);
current = CONTAINING_RECORD(current_entry,
ROS_VACB,
- BcbVacbListEntry);
+ CacheMapVacbListEntry);
CcRosInternalFreeVacb(current);
}
NTSTATUS
NTAPI
CcRosReleaseVacb (
- PBCB Bcb,
+ PROS_SHARED_CACHE_MAP SharedCacheMap,
PROS_VACB Vacb,
BOOLEAN Valid,
BOOLEAN Dirty,
BOOLEAN WasDirty;
KIRQL oldIrql;
- ASSERT(Bcb);
+ ASSERT(SharedCacheMap);
- DPRINT("CcRosReleaseVacb(Bcb 0x%p, Vacb 0x%p, Valid %u)\n",
- Bcb, Vacb, Valid);
+ DPRINT("CcRosReleaseVacb(SharedCacheMap 0x%p, Vacb 0x%p, Valid %u)\n",
+ SharedCacheMap, Vacb, Valid);
KeAcquireGuardedMutex(&ViewLock);
- KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
+ KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
Vacb->Valid = Valid;
CcRosVacbIncRefCount(Vacb);
}
- KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+ KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock);
KeReleaseMutex(&Vacb->Mutex, FALSE);
PROS_VACB
NTAPI
CcRosLookupVacb (
- PBCB Bcb,
- ULONG FileOffset)
+ PROS_SHARED_CACHE_MAP SharedCacheMap,
+ LONGLONG FileOffset)
{
PLIST_ENTRY current_entry;
PROS_VACB current;
KIRQL oldIrql;
- ASSERT(Bcb);
+ ASSERT(SharedCacheMap);
- DPRINT("CcRosLookupVacb(Bcb -x%p, FileOffset %lu)\n", Bcb, FileOffset);
+ DPRINT("CcRosLookupVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
+ SharedCacheMap, FileOffset);
KeAcquireGuardedMutex(&ViewLock);
- KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
+ KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
- current_entry = Bcb->BcbVacbListHead.Flink;
- while (current_entry != &Bcb->BcbVacbListHead)
+ current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
+ while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
{
current = CONTAINING_RECORD(current_entry,
ROS_VACB,
- BcbVacbListEntry);
- if (IsPointInRange(current->FileOffset, VACB_MAPPING_GRANULARITY,
+ CacheMapVacbListEntry);
+ if (IsPointInRange(current->FileOffset.QuadPart,
+ VACB_MAPPING_GRANULARITY,
FileOffset))
{
CcRosVacbIncRefCount(current);
- KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+ KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock);
KeWaitForSingleObject(¤t->Mutex,
Executive,
NULL);
return current;
}
- if (current->FileOffset > FileOffset)
+ if (current->FileOffset.QuadPart > FileOffset)
break;
current_entry = current_entry->Flink;
}
- KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+ KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock);
return NULL;
NTSTATUS
NTAPI
CcRosMarkDirtyVacb (
- PBCB Bcb,
- ULONG FileOffset)
+ PROS_SHARED_CACHE_MAP SharedCacheMap,
+ LONGLONG FileOffset)
{
PROS_VACB Vacb;
KIRQL oldIrql;
- ASSERT(Bcb);
+ ASSERT(SharedCacheMap);
- DPRINT("CcRosMarkDirtyVacb(Bcb 0x%p, FileOffset %lu)\n", Bcb, FileOffset);
+ DPRINT("CcRosMarkDirtyVacb(SharedCacheMap 0x%p, FileOffset %I64u)\n",
+ SharedCacheMap, FileOffset);
- Vacb = CcRosLookupVacb(Bcb, FileOffset);
+ Vacb = CcRosLookupVacb(SharedCacheMap, FileOffset);
if (Vacb == NULL)
{
KeBugCheck(CACHE_MANAGER);
}
KeAcquireGuardedMutex(&ViewLock);
- KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
+ KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
if (!Vacb->Dirty)
{
Vacb->Dirty = TRUE;
- KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+ KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock);
KeReleaseMutex(&Vacb->Mutex, FALSE);
NTSTATUS
NTAPI
CcRosUnmapVacb (
- PBCB Bcb,
- ULONG FileOffset,
+ PROS_SHARED_CACHE_MAP SharedCacheMap,
+ LONGLONG FileOffset,
BOOLEAN NowDirty)
{
PROS_VACB Vacb;
BOOLEAN WasDirty;
KIRQL oldIrql;
- ASSERT(Bcb);
+ ASSERT(SharedCacheMap);
- DPRINT("CcRosUnmapVacb(Bcb 0x%p, FileOffset %lu, NowDirty %u)\n",
- Bcb, FileOffset, NowDirty);
+ DPRINT("CcRosUnmapVacb(SharedCacheMap 0x%p, FileOffset %I64u, NowDirty %u)\n",
+ SharedCacheMap, FileOffset, NowDirty);
- Vacb = CcRosLookupVacb(Bcb, FileOffset);
+ Vacb = CcRosLookupVacb(SharedCacheMap, FileOffset);
if (Vacb == NULL)
{
return STATUS_UNSUCCESSFUL;
}
KeAcquireGuardedMutex(&ViewLock);
- KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
+ KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
WasDirty = Vacb->Dirty;
Vacb->Dirty = Vacb->Dirty || NowDirty;
CcRosVacbDecRefCount(Vacb);
}
- KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+ KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock);
KeReleaseMutex(&Vacb->Mutex, FALSE);
static
NTSTATUS
CcRosCreateVacb (
- PBCB Bcb,
- ULONG FileOffset,
+ PROS_SHARED_CACHE_MAP SharedCacheMap,
+ LONGLONG FileOffset,
PROS_VACB *Vacb)
{
PROS_VACB current;
NTSTATUS Status;
KIRQL oldIrql;
- ASSERT(Bcb);
+ ASSERT(SharedCacheMap);
DPRINT("CcRosCreateVacb()\n");
- if (FileOffset >= Bcb->FileSize.u.LowPart)
+ if (FileOffset >= SharedCacheMap->FileSize.QuadPart)
{
*Vacb = NULL;
return STATUS_INVALID_PARAMETER;
current->Valid = FALSE;
current->Dirty = FALSE;
current->PageOut = FALSE;
- current->FileOffset = ROUND_DOWN(FileOffset, VACB_MAPPING_GRANULARITY);
- current->Bcb = Bcb;
+ current->FileOffset.QuadPart = ROUND_DOWN(FileOffset, VACB_MAPPING_GRANULARITY);
+ current->SharedCacheMap = SharedCacheMap;
#if DBG
- if ( Bcb->Trace )
+ if (SharedCacheMap->Trace)
{
- DPRINT1("CacheMap 0x%p: new VACB: 0x%p\n", Bcb, current );
+ DPRINT1("CacheMap 0x%p: new VACB: 0x%p\n", SharedCacheMap, current);
}
#endif
current->MappedCount = 0;
* file offset exist. If there is a VACB, we release
* our newly created VACB and return the existing one.
*/
- KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
- current_entry = Bcb->BcbVacbListHead.Flink;
+ KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
+ current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
previous = NULL;
- while (current_entry != &Bcb->BcbVacbListHead)
+ while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
{
current = CONTAINING_RECORD(current_entry,
ROS_VACB,
- BcbVacbListEntry);
- if (IsPointInRange(current->FileOffset, VACB_MAPPING_GRANULARITY,
+ CacheMapVacbListEntry);
+ if (IsPointInRange(current->FileOffset.QuadPart,
+ VACB_MAPPING_GRANULARITY,
FileOffset))
{
CcRosVacbIncRefCount(current);
- KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+ KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
#if DBG
- if ( Bcb->Trace )
+ if (SharedCacheMap->Trace)
{
DPRINT1("CacheMap 0x%p: deleting newly created VACB 0x%p ( found existing one 0x%p )\n",
- Bcb,
+ SharedCacheMap,
(*Vacb),
- current );
+ current);
}
#endif
KeReleaseMutex(&(*Vacb)->Mutex, FALSE);
NULL);
return STATUS_SUCCESS;
}
- if (current->FileOffset < FileOffset)
+ if (current->FileOffset.QuadPart < FileOffset)
{
ASSERT(previous == NULL ||
- previous->FileOffset < current->FileOffset);
+ previous->FileOffset.QuadPart < current->FileOffset.QuadPart);
previous = current;
}
- if (current->FileOffset > FileOffset)
+ if (current->FileOffset.QuadPart > FileOffset)
break;
current_entry = current_entry->Flink;
}
current = *Vacb;
if (previous)
{
- InsertHeadList(&previous->BcbVacbListEntry, ¤t->BcbVacbListEntry);
+ InsertHeadList(&previous->CacheMapVacbListEntry, ¤t->CacheMapVacbListEntry);
}
else
{
- InsertHeadList(&Bcb->BcbVacbListHead, ¤t->BcbVacbListEntry);
+ InsertHeadList(&SharedCacheMap->CacheMapVacbListHead, ¤t->CacheMapVacbListEntry);
}
- KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
- InsertTailList(&VacbListHead, ¤t->VacbListEntry);
+ KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
InsertTailList(&VacbLruListHead, ¤t->VacbLruListEntry);
KeReleaseGuardedMutex(&ViewLock);
/* Create a virtual mapping for this memory area */
MI_SET_USAGE(MI_USAGE_CACHE);
#if MI_TRACE_PFNS
- PWCHAR pos = NULL;
- ULONG len = 0;
- if ((Bcb->FileObject) && (Bcb->FileObject->FileName.Buffer))
+ if ((SharedCacheMap->FileObject) && (SharedCacheMap->FileObject->FileName.Buffer))
{
- pos = wcsrchr(Bcb->FileObject->FileName.Buffer, '\\');
+ PWCHAR pos = NULL;
+ ULONG len = 0;
+ pos = wcsrchr(SharedCacheMap->FileObject->FileName.Buffer, '\\');
len = wcslen(pos) * sizeof(WCHAR);
if (pos) snprintf(MI_PFN_CURRENT_PROCESS_NAME, min(16, len), "%S", pos);
}
return STATUS_SUCCESS;
}
-NTSTATUS
-NTAPI
-CcRosGetVacbChain (
- PBCB Bcb,
- ULONG FileOffset,
- ULONG Length,
- PROS_VACB *Vacb)
-{
- PROS_VACB current;
- ULONG i;
- PROS_VACB *VacbList;
- PROS_VACB Previous = NULL;
-
- ASSERT(Bcb);
-
- DPRINT("CcRosGetVacbChain()\n");
-
- Length = ROUND_UP(Length, VACB_MAPPING_GRANULARITY);
-
- VacbList = _alloca(sizeof(PROS_VACB) *
- (Length / VACB_MAPPING_GRANULARITY));
-
- /*
- * Look for a VACB already mapping the same data.
- */
- for (i = 0; i < (Length / VACB_MAPPING_GRANULARITY); i++)
- {
- ULONG CurrentOffset = FileOffset + (i * VACB_MAPPING_GRANULARITY);
- current = CcRosLookupVacb(Bcb, CurrentOffset);
- if (current != NULL)
- {
- KeAcquireGuardedMutex(&ViewLock);
-
- /* Move to tail of LRU list */
- RemoveEntryList(¤t->VacbLruListEntry);
- InsertTailList(&VacbLruListHead, ¤t->VacbLruListEntry);
-
- KeReleaseGuardedMutex(&ViewLock);
-
- VacbList[i] = current;
- }
- else
- {
- CcRosCreateVacb(Bcb, CurrentOffset, ¤t);
- VacbList[i] = current;
- }
- }
-
- for (i = 0; i < Length / VACB_MAPPING_GRANULARITY; i++)
- {
- if (i == 0)
- {
- *Vacb = VacbList[i];
- Previous = VacbList[i];
- }
- else
- {
- Previous->NextInChain = VacbList[i];
- Previous = VacbList[i];
- }
- }
- ASSERT(Previous);
- Previous->NextInChain = NULL;
-
- return STATUS_SUCCESS;
-}
-
NTSTATUS
NTAPI
CcRosGetVacb (
- PBCB Bcb,
- ULONG FileOffset,
- PULONG BaseOffset,
+ PROS_SHARED_CACHE_MAP SharedCacheMap,
+ LONGLONG FileOffset,
+ PLONGLONG BaseOffset,
PVOID* BaseAddress,
PBOOLEAN UptoDate,
PROS_VACB *Vacb)
PROS_VACB current;
NTSTATUS Status;
- ASSERT(Bcb);
+ ASSERT(SharedCacheMap);
DPRINT("CcRosGetVacb()\n");
/*
* Look for a VACB already mapping the same data.
*/
- current = CcRosLookupVacb(Bcb, FileOffset);
+ current = CcRosLookupVacb(SharedCacheMap, FileOffset);
if (current == NULL)
{
/*
* Otherwise create a new VACB.
*/
- Status = CcRosCreateVacb(Bcb, FileOffset, ¤t);
+ Status = CcRosCreateVacb(SharedCacheMap, FileOffset, ¤t);
if (!NT_SUCCESS(Status))
{
return Status;
*BaseAddress = current->BaseAddress;
DPRINT("*BaseAddress %p\n", *BaseAddress);
*Vacb = current;
- *BaseOffset = current->FileOffset;
+ *BaseOffset = current->FileOffset.QuadPart;
return STATUS_SUCCESS;
}
NTSTATUS
NTAPI
CcRosRequestVacb (
- PBCB Bcb,
- ULONG FileOffset,
+ PROS_SHARED_CACHE_MAP SharedCacheMap,
+ LONGLONG FileOffset,
PVOID* BaseAddress,
PBOOLEAN UptoDate,
PROS_VACB *Vacb)
/*
- * FUNCTION: Request a page mapping for a BCB
+ * FUNCTION: Request a page mapping for a shared cache map
*/
{
- ULONG BaseOffset;
+ LONGLONG BaseOffset;
- ASSERT(Bcb);
+ ASSERT(SharedCacheMap);
if (FileOffset % VACB_MAPPING_GRANULARITY != 0)
{
- DPRINT1("Bad fileoffset %x should be multiple of %x",
+ DPRINT1("Bad fileoffset %I64x should be multiple of %x",
FileOffset, VACB_MAPPING_GRANULARITY);
KeBugCheck(CACHE_MANAGER);
}
- return CcRosGetVacb(Bcb,
+ return CcRosGetVacb(SharedCacheMap,
FileOffset,
&BaseOffset,
BaseAddress,
CcRosInternalFreeVacb (
PROS_VACB Vacb)
/*
- * FUNCTION: Releases a VACB associated with a BCB
+ * FUNCTION: Releases a VACB associated with a shared cache map
*/
{
DPRINT("Freeing VACB 0x%p\n", Vacb);
#if DBG
- if (Vacb->Bcb->Trace)
+ if (Vacb->SharedCacheMap->Trace)
{
- DPRINT1("CacheMap 0x%p: deleting VACB: 0x%p\n", Vacb->Bcb, Vacb);
+ DPRINT1("CacheMap 0x%p: deleting VACB: 0x%p\n", Vacb->SharedCacheMap, Vacb);
}
#endif
IN ULONG Length,
OUT PIO_STATUS_BLOCK IoStatus)
{
- PBCB Bcb;
+ PROS_SHARED_CACHE_MAP SharedCacheMap;
LARGE_INTEGER Offset;
+ LONGLONG RemainingLength;
PROS_VACB current;
NTSTATUS Status;
KIRQL oldIrql;
if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
{
- Bcb = (PBCB)SectionObjectPointers->SharedCacheMap;
- ASSERT(Bcb);
+ SharedCacheMap = SectionObjectPointers->SharedCacheMap;
+ ASSERT(SharedCacheMap);
if (FileOffset)
{
Offset = *FileOffset;
+ RemainingLength = Length;
}
else
{
- Offset.QuadPart = (LONGLONG)0;
- Length = Bcb->FileSize.u.LowPart;
+ Offset.QuadPart = 0;
+ RemainingLength = SharedCacheMap->FileSize.QuadPart;
}
if (IoStatus)
IoStatus->Information = 0;
}
- while (Length > 0)
+ while (RemainingLength > 0)
{
- current = CcRosLookupVacb(Bcb, Offset.u.LowPart);
+ current = CcRosLookupVacb(SharedCacheMap, Offset.QuadPart);
if (current != NULL)
{
if (current->Dirty)
KeReleaseMutex(¤t->Mutex, FALSE);
KeAcquireGuardedMutex(&ViewLock);
- KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
+ KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
CcRosVacbDecRefCount(current);
- KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+ KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock);
}
Offset.QuadPart += VACB_MAPPING_GRANULARITY;
- if (Length > VACB_MAPPING_GRANULARITY)
- {
- Length -= VACB_MAPPING_GRANULARITY;
- }
- else
- {
- Length = 0;
- }
+ RemainingLength -= min(RemainingLength, VACB_MAPPING_GRANULARITY);
}
}
else
NTAPI
CcRosDeleteFileCache (
PFILE_OBJECT FileObject,
- PBCB Bcb)
+ PROS_SHARED_CACHE_MAP SharedCacheMap)
/*
- * FUNCTION: Releases the BCB associated with a file object
+ * FUNCTION: Releases the shared cache map associated with a file object
*/
{
PLIST_ENTRY current_entry;
LIST_ENTRY FreeList;
KIRQL oldIrql;
- ASSERT(Bcb);
+ ASSERT(SharedCacheMap);
- Bcb->RefCount++;
+ SharedCacheMap->RefCount++;
KeReleaseGuardedMutex(&ViewLock);
CcFlushCache(FileObject->SectionObjectPointer, NULL, 0, NULL);
KeAcquireGuardedMutex(&ViewLock);
- Bcb->RefCount--;
- if (Bcb->RefCount == 0)
+ SharedCacheMap->RefCount--;
+ if (SharedCacheMap->RefCount == 0)
{
- if (Bcb->BcbRemoveListEntry.Flink != NULL)
- {
- RemoveEntryList(&Bcb->BcbRemoveListEntry);
- Bcb->BcbRemoveListEntry.Flink = NULL;
- }
-
FileObject->SectionObjectPointer->SharedCacheMap = NULL;
/*
* Release all VACBs
*/
InitializeListHead(&FreeList);
- KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
- while (!IsListEmpty(&Bcb->BcbVacbListHead))
+ KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
+ while (!IsListEmpty(&SharedCacheMap->CacheMapVacbListHead))
{
- current_entry = RemoveTailList(&Bcb->BcbVacbListHead);
- current = CONTAINING_RECORD(current_entry, ROS_VACB, BcbVacbListEntry);
- RemoveEntryList(¤t->VacbListEntry);
+ current_entry = RemoveTailList(&SharedCacheMap->CacheMapVacbListHead);
+ current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
RemoveEntryList(¤t->VacbLruListEntry);
if (current->Dirty)
{
DirtyPageCount -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
DPRINT1("Freeing dirty VACB\n");
}
- InsertHeadList(&FreeList, ¤t->BcbVacbListEntry);
+ InsertHeadList(&FreeList, ¤t->CacheMapVacbListEntry);
}
#if DBG
- Bcb->Trace = FALSE;
+ SharedCacheMap->Trace = FALSE;
#endif
- KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+ KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock);
- ObDereferenceObject (Bcb->FileObject);
+ ObDereferenceObject(SharedCacheMap->FileObject);
while (!IsListEmpty(&FreeList))
{
current_entry = RemoveTailList(&FreeList);
- current = CONTAINING_RECORD(current_entry, ROS_VACB, BcbVacbListEntry);
+ current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
CcRosInternalFreeVacb(current);
}
- ExFreeToNPagedLookasideList(&BcbLookasideList, Bcb);
+ ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap);
KeAcquireGuardedMutex(&ViewLock);
}
return STATUS_SUCCESS;
CcRosReferenceCache (
PFILE_OBJECT FileObject)
{
- PBCB Bcb;
+ PROS_SHARED_CACHE_MAP SharedCacheMap;
KeAcquireGuardedMutex(&ViewLock);
- Bcb = (PBCB)FileObject->SectionObjectPointer->SharedCacheMap;
- ASSERT(Bcb);
- if (Bcb->RefCount == 0)
- {
- ASSERT(Bcb->BcbRemoveListEntry.Flink != NULL);
- RemoveEntryList(&Bcb->BcbRemoveListEntry);
- Bcb->BcbRemoveListEntry.Flink = NULL;
-
- }
- else
- {
- ASSERT(Bcb->BcbRemoveListEntry.Flink == NULL);
- }
- Bcb->RefCount++;
+ SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
+ ASSERT(SharedCacheMap);
+ ASSERT(SharedCacheMap->RefCount != 0);
+ SharedCacheMap->RefCount++;
KeReleaseGuardedMutex(&ViewLock);
}
VOID
NTAPI
-CcRosSetRemoveOnClose (
+CcRosRemoveIfClosed (
PSECTION_OBJECT_POINTERS SectionObjectPointer)
{
- PBCB Bcb;
- DPRINT("CcRosSetRemoveOnClose()\n");
+ PROS_SHARED_CACHE_MAP SharedCacheMap;
+ DPRINT("CcRosRemoveIfClosed()\n");
KeAcquireGuardedMutex(&ViewLock);
- Bcb = (PBCB)SectionObjectPointer->SharedCacheMap;
- if (Bcb)
+ SharedCacheMap = SectionObjectPointer->SharedCacheMap;
+ if (SharedCacheMap && SharedCacheMap->RefCount == 0)
{
- Bcb->RemoveOnClose = TRUE;
- if (Bcb->RefCount == 0)
- {
- CcRosDeleteFileCache(Bcb->FileObject, Bcb);
- }
+ CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap);
}
KeReleaseGuardedMutex(&ViewLock);
}
CcRosDereferenceCache (
PFILE_OBJECT FileObject)
{
- PBCB Bcb;
+ PROS_SHARED_CACHE_MAP SharedCacheMap;
KeAcquireGuardedMutex(&ViewLock);
- Bcb = (PBCB)FileObject->SectionObjectPointer->SharedCacheMap;
- ASSERT(Bcb);
- if (Bcb->RefCount > 0)
+ SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
+ ASSERT(SharedCacheMap);
+ if (SharedCacheMap->RefCount > 0)
{
- Bcb->RefCount--;
- if (Bcb->RefCount == 0)
+ SharedCacheMap->RefCount--;
+ if (SharedCacheMap->RefCount == 0)
{
- MmFreeSectionSegments(Bcb->FileObject);
- CcRosDeleteFileCache(FileObject, Bcb);
+ MmFreeSectionSegments(SharedCacheMap->FileObject);
+ CcRosDeleteFileCache(FileObject, SharedCacheMap);
}
}
KeReleaseGuardedMutex(&ViewLock);
* has been closed.
*/
{
- PBCB Bcb;
+ PROS_SHARED_CACHE_MAP SharedCacheMap;
KeAcquireGuardedMutex(&ViewLock);
if (FileObject->SectionObjectPointer->SharedCacheMap != NULL)
{
- Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
+ SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
if (FileObject->PrivateCacheMap != NULL)
{
FileObject->PrivateCacheMap = NULL;
- if (Bcb->RefCount > 0)
+ if (SharedCacheMap->RefCount > 0)
{
- Bcb->RefCount--;
- if (Bcb->RefCount == 0)
+ SharedCacheMap->RefCount--;
+ if (SharedCacheMap->RefCount == 0)
{
- MmFreeSectionSegments(Bcb->FileObject);
- CcRosDeleteFileCache(FileObject, Bcb);
+ MmFreeSectionSegments(SharedCacheMap->FileObject);
+ CcRosDeleteFileCache(FileObject, SharedCacheMap);
}
}
}
CcTryToInitializeFileCache (
PFILE_OBJECT FileObject)
{
- PBCB Bcb;
+ PROS_SHARED_CACHE_MAP SharedCacheMap;
NTSTATUS Status;
KeAcquireGuardedMutex(&ViewLock);
ASSERT(FileObject->SectionObjectPointer);
- Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
- if (Bcb == NULL)
+ SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
+ if (SharedCacheMap == NULL)
{
Status = STATUS_UNSUCCESSFUL;
}
{
if (FileObject->PrivateCacheMap == NULL)
{
- FileObject->PrivateCacheMap = Bcb;
- Bcb->RefCount++;
- }
- if (Bcb->BcbRemoveListEntry.Flink != NULL)
- {
- RemoveEntryList(&Bcb->BcbRemoveListEntry);
- Bcb->BcbRemoveListEntry.Flink = NULL;
+ FileObject->PrivateCacheMap = SharedCacheMap;
+ SharedCacheMap->RefCount++;
}
Status = STATUS_SUCCESS;
}
NTAPI
CcRosInitializeFileCache (
PFILE_OBJECT FileObject,
+ PCC_FILE_SIZES FileSizes,
PCACHE_MANAGER_CALLBACKS CallBacks,
PVOID LazyWriterContext)
/*
- * FUNCTION: Initializes a BCB for a file object
+ * FUNCTION: Initializes a shared cache map for a file object
*/
{
- PBCB Bcb;
+ PROS_SHARED_CACHE_MAP SharedCacheMap;
- Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
- DPRINT("CcRosInitializeFileCache(FileObject 0x%p, Bcb 0x%p)\n",
- FileObject, Bcb);
+ SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
+ DPRINT("CcRosInitializeFileCache(FileObject 0x%p, SharedCacheMap 0x%p)\n",
+ FileObject, SharedCacheMap);
KeAcquireGuardedMutex(&ViewLock);
- if (Bcb == NULL)
+ if (SharedCacheMap == NULL)
{
- Bcb = ExAllocateFromNPagedLookasideList(&BcbLookasideList);
- if (Bcb == NULL)
+ SharedCacheMap = ExAllocateFromNPagedLookasideList(&SharedCacheMapLookasideList);
+ if (SharedCacheMap == NULL)
{
KeReleaseGuardedMutex(&ViewLock);
return STATUS_UNSUCCESSFUL;
}
- RtlZeroMemory(Bcb, sizeof(*Bcb));
+ RtlZeroMemory(SharedCacheMap, sizeof(*SharedCacheMap));
ObReferenceObjectByPointer(FileObject,
FILE_ALL_ACCESS,
NULL,
KernelMode);
- Bcb->FileObject = FileObject;
- Bcb->Callbacks = CallBacks;
- Bcb->LazyWriteContext = LazyWriterContext;
- if (FileObject->FsContext)
- {
- Bcb->AllocationSize =
- ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->AllocationSize;
- Bcb->FileSize =
- ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->FileSize;
- }
- KeInitializeSpinLock(&Bcb->BcbLock);
- InitializeListHead(&Bcb->BcbVacbListHead);
- FileObject->SectionObjectPointer->SharedCacheMap = Bcb;
+ SharedCacheMap->FileObject = FileObject;
+ SharedCacheMap->Callbacks = CallBacks;
+ SharedCacheMap->LazyWriteContext = LazyWriterContext;
+ SharedCacheMap->SectionSize = FileSizes->AllocationSize;
+ SharedCacheMap->FileSize = FileSizes->FileSize;
+ KeInitializeSpinLock(&SharedCacheMap->CacheMapLock);
+ InitializeListHead(&SharedCacheMap->CacheMapVacbListHead);
+ FileObject->SectionObjectPointer->SharedCacheMap = SharedCacheMap;
}
if (FileObject->PrivateCacheMap == NULL)
{
- FileObject->PrivateCacheMap = Bcb;
- Bcb->RefCount++;
- }
- if (Bcb->BcbRemoveListEntry.Flink != NULL)
- {
- RemoveEntryList(&Bcb->BcbRemoveListEntry);
- Bcb->BcbRemoveListEntry.Flink = NULL;
+ FileObject->PrivateCacheMap = SharedCacheMap;
+ SharedCacheMap->RefCount++;
}
KeReleaseGuardedMutex(&ViewLock);
CcGetFileObjectFromSectionPtrs (
IN PSECTION_OBJECT_POINTERS SectionObjectPointers)
{
- PBCB Bcb;
+ PROS_SHARED_CACHE_MAP SharedCacheMap;
if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
{
- Bcb = (PBCB)SectionObjectPointers->SharedCacheMap;
- ASSERT(Bcb);
- return Bcb->FileObject;
+ SharedCacheMap = SectionObjectPointers->SharedCacheMap;
+ ASSERT(SharedCacheMap);
+ return SharedCacheMap->FileObject;
}
return NULL;
}
{
DPRINT("CcInitView()\n");
- InitializeListHead(&VacbListHead);
InitializeListHead(&DirtyVacbListHead);
InitializeListHead(&VacbLruListHead);
- InitializeListHead(&ClosedListHead);
KeInitializeGuardedMutex(&ViewLock);
- ExInitializeNPagedLookasideList (&iBcbLookasideList,
- NULL,
- NULL,
- 0,
- sizeof(INTERNAL_BCB),
- TAG_IBCB,
- 20);
- ExInitializeNPagedLookasideList (&BcbLookasideList,
- NULL,
- NULL,
- 0,
- sizeof(BCB),
- TAG_BCB,
- 20);
- ExInitializeNPagedLookasideList (&VacbLookasideList,
- NULL,
- NULL,
- 0,
- sizeof(ROS_VACB),
- TAG_CSEG,
- 20);
+ ExInitializeNPagedLookasideList(&iBcbLookasideList,
+ NULL,
+ NULL,
+ 0,
+ sizeof(INTERNAL_BCB),
+ TAG_BCB,
+ 20);
+ ExInitializeNPagedLookasideList(&SharedCacheMapLookasideList,
+ NULL,
+ NULL,
+ 0,
+ sizeof(ROS_SHARED_CACHE_MAP),
+ TAG_SHARED_CACHE_MAP,
+ 20);
+ ExInitializeNPagedLookasideList(&VacbLookasideList,
+ NULL,
+ NULL,
+ 0,
+ sizeof(ROS_VACB),
+ TAG_VACB,
+ 20);
MmInitializeMemoryConsumer(MC_CACHE, CcRosTrimCache);
CcInitCacheZeroPage();
-
}
/* EOF */
projects / reactos.git / blobdiff