Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-05-08 03:07:05 +00:00
Code Issues Projects Releases Packages Wiki Activity

[NTOS:CC]

Browse source 
- Rename the BCB structure to ROS_SHARED_CACHE_MAP. This should eventually become NDK's SHARED_CACHE_MAP.
CORE-8065

svn path=/trunk/; revision=62713
This commit is contained in:
Thomas Faber 2014-04-12 10:59:48 +00:00
parent 4168725e49
commit 6d7fbc887f
6 changed files with 304 additions and 301 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

97
reactos/ntoskrnl/cc/copy.c
View file

@ -57,7 +57,7 @@ CcInitCacheZeroPage (
NTSTATUS NTSTATUS
NTAPI NTAPI
ReadVacbChain ( ReadVacbChain (
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
ULONG ReadOffset, ULONG ReadOffset,
ULONG Length, ULONG Length,
PVOID Buffer) PVOID Buffer)
@ -74,7 +74,7 @@ ReadVacbChain (
Mdl = _alloca(MmSizeOfMdl(NULL, MAX_RW_LENGTH)); Mdl = _alloca(MmSizeOfMdl(NULL, MAX_RW_LENGTH));
Status = CcRosGetVacbChain(Bcb, ReadOffset, Length, &head); Status = CcRosGetVacbChain(SharedCacheMap, ReadOffset, Length, &head);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
return Status; return Status;
@ -95,7 +95,7 @@ ReadVacbChain (
Length = Length - TempLength; Length = Length - TempLength;
previous = current; previous = current;
current = current->NextInChain; current = current->NextInChain;
CcRosReleaseVacb(Bcb, previous, TRUE, FALSE, FALSE); CcRosReleaseVacb(SharedCacheMap, previous, TRUE, FALSE, FALSE);
} }
/* /*
* Otherwise read in as much as we can. * Otherwise read in as much as we can.
@ -143,7 +143,7 @@ ReadVacbChain (
*/ */
VacbOffset.QuadPart = current->FileOffset; VacbOffset.QuadPart = current->FileOffset;
KeInitializeEvent(&Event, NotificationEvent, FALSE); KeInitializeEvent(&Event, NotificationEvent, FALSE);
Status = IoPageRead(Bcb->FileObject, Status = IoPageRead(SharedCacheMap->FileObject,
Mdl, Mdl,
&VacbOffset, &VacbOffset,
&Event, &Event,
@ -163,7 +163,7 @@ ReadVacbChain (
{ {
previous = current; previous = current;
current = current->NextInChain; current = current->NextInChain;
CcRosReleaseVacb(Bcb, previous, FALSE, FALSE, FALSE); CcRosReleaseVacb(SharedCacheMap, previous, FALSE, FALSE, FALSE);
} }
return Status; return Status;
} }
@ -178,7 +178,7 @@ ReadVacbChain (
Buffer = (PVOID)((ULONG_PTR)Buffer + TempLength); Buffer = (PVOID)((ULONG_PTR)Buffer + TempLength);
Length = Length - TempLength; Length = Length - TempLength;
CcRosReleaseVacb(Bcb, previous, TRUE, FALSE, FALSE); CcRosReleaseVacb(SharedCacheMap, previous, TRUE, FALSE, FALSE);
current_size += VACB_MAPPING_GRANULARITY; current_size += VACB_MAPPING_GRANULARITY;
} }
} }
@ -199,7 +199,7 @@ CcReadVirtualAddress (
KEVENT Event; KEVENT Event;
VacbOffset.QuadPart = Vacb->FileOffset; VacbOffset.QuadPart = Vacb->FileOffset;
Size = (ULONG)(Vacb->Bcb->AllocationSize.QuadPart - Vacb->FileOffset); Size = (ULONG)(Vacb->SharedCacheMap->AllocationSize.QuadPart - Vacb->FileOffset);
if (Size > VACB_MAPPING_GRANULARITY) if (Size > VACB_MAPPING_GRANULARITY)
{ {
Size = VACB_MAPPING_GRANULARITY; Size = VACB_MAPPING_GRANULARITY;
@ -214,7 +214,7 @@ CcReadVirtualAddress (
MmBuildMdlForNonPagedPool(Mdl); MmBuildMdlForNonPagedPool(Mdl);
Mdl->MdlFlags |= MDL_IO_PAGE_READ; Mdl->MdlFlags |= MDL_IO_PAGE_READ;
KeInitializeEvent(&Event, NotificationEvent, FALSE); KeInitializeEvent(&Event, NotificationEvent, FALSE);
Status = IoPageRead(Vacb->Bcb->FileObject, Mdl, &VacbOffset, &Event, &IoStatus); Status = IoPageRead(Vacb->SharedCacheMap->FileObject, Mdl, &VacbOffset, &Event, &IoStatus);
if (Status == STATUS_PENDING) if (Status == STATUS_PENDING)
{ {
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL); KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
@ -252,7 +252,7 @@ CcWriteVirtualAddress (
Vacb->Dirty = FALSE; Vacb->Dirty = FALSE;
VacbOffset.QuadPart = Vacb->FileOffset; VacbOffset.QuadPart = Vacb->FileOffset;
Size = (ULONG)(Vacb->Bcb->AllocationSize.QuadPart - Vacb->FileOffset); Size = (ULONG)(Vacb->SharedCacheMap->AllocationSize.QuadPart - Vacb->FileOffset);
if (Size > VACB_MAPPING_GRANULARITY) if (Size > VACB_MAPPING_GRANULARITY)
{ {
Size = VACB_MAPPING_GRANULARITY; Size = VACB_MAPPING_GRANULARITY;
@ -277,7 +277,7 @@ CcWriteVirtualAddress (
MmBuildMdlForNonPagedPool(Mdl); MmBuildMdlForNonPagedPool(Mdl);
Mdl->MdlFlags |= MDL_IO_PAGE_READ; Mdl->MdlFlags |= MDL_IO_PAGE_READ;
KeInitializeEvent(&Event, NotificationEvent, FALSE); KeInitializeEvent(&Event, NotificationEvent, FALSE);
Status = IoSynchronousPageWrite(Vacb->Bcb->FileObject, Mdl, &VacbOffset, &Event, &IoStatus); Status = IoSynchronousPageWrite(Vacb->SharedCacheMap->FileObject, Mdl, &VacbOffset, &Event, &IoStatus);
if (Status == STATUS_PENDING) if (Status == STATUS_PENDING)
{ {
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL); KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
@ -331,7 +331,7 @@ CcCopyRead (
PROS_VACB Vacb; PROS_VACB Vacb;
BOOLEAN Valid; BOOLEAN Valid;
ULONG ReadLength = 0; ULONG ReadLength = 0;
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
KIRQL oldirql; KIRQL oldirql;
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
PROS_VACB current; PROS_VACB current;
@ -341,12 +341,12 @@ CcCopyRead (
FileObject, FileOffset->QuadPart, Length, Wait, FileObject, FileOffset->QuadPart, Length, Wait,
Buffer, IoStatus); Buffer, IoStatus);
Bcb = FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
ReadOffset = (ULONG)FileOffset->QuadPart; ReadOffset = (ULONG)FileOffset->QuadPart;
DPRINT("AllocationSize %I64d, FileSize %I64d\n", DPRINT("AllocationSize %I64d, FileSize %I64d\n",
Bcb->AllocationSize.QuadPart, SharedCacheMap->AllocationSize.QuadPart,
Bcb->FileSize.QuadPart); SharedCacheMap->FileSize.QuadPart);
/* /*
* Check for the nowait case that all the cache VACBs that would * Check for the nowait case that all the cache VACBs that would
@ -354,19 +354,20 @@ CcCopyRead (
*/ */
if (!Wait) if (!Wait)
{ {
KeAcquireSpinLock(&Bcb->BcbLock, &oldirql); KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldirql);
/* FIXME: this loop doesn't take into account areas that don't have /* FIXME: this loop doesn't take into account areas that don't have
* a VACB in the list yet */ * a VACB in the list yet */
current_entry = Bcb->BcbVacbListHead.Flink; current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
while (current_entry != &Bcb->BcbVacbListHead) while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
{ {
current = CONTAINING_RECORD(current_entry, ROS_VACB, current = CONTAINING_RECORD(current_entry,
BcbVacbListEntry); ROS_VACB,
CacheMapVacbListEntry);
if (!current->Valid && if (!current->Valid &&
DoRangesIntersect(current->FileOffset, VACB_MAPPING_GRANULARITY, DoRangesIntersect(current->FileOffset, VACB_MAPPING_GRANULARITY,
ReadOffset, Length)) ReadOffset, Length))
{ {
KeReleaseSpinLock(&Bcb->BcbLock, oldirql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
IoStatus->Status = STATUS_UNSUCCESSFUL; IoStatus->Status = STATUS_UNSUCCESSFUL;
IoStatus->Information = 0; IoStatus->Information = 0;
return FALSE; return FALSE;
@ -375,14 +376,14 @@ CcCopyRead (
break; break;
current_entry = current_entry->Flink; current_entry = current_entry->Flink;
} }
KeReleaseSpinLock(&Bcb->BcbLock, oldirql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
} }
TempLength = ReadOffset % VACB_MAPPING_GRANULARITY; TempLength = ReadOffset % VACB_MAPPING_GRANULARITY;
if (TempLength != 0) if (TempLength != 0)
{ {
TempLength = min(Length, VACB_MAPPING_GRANULARITY - TempLength); TempLength = min(Length, VACB_MAPPING_GRANULARITY - TempLength);
Status = CcRosRequestVacb(Bcb, Status = CcRosRequestVacb(SharedCacheMap,
ROUND_DOWN(ReadOffset, ROUND_DOWN(ReadOffset,
VACB_MAPPING_GRANULARITY), VACB_MAPPING_GRANULARITY),
&BaseAddress, &Valid, &Vacb); &BaseAddress, &Valid, &Vacb);
@ -400,14 +401,14 @@ CcCopyRead (
{ {
IoStatus->Information = 0; IoStatus->Information = 0;
IoStatus->Status = Status; IoStatus->Status = Status;
CcRosReleaseVacb(Bcb, Vacb, FALSE, FALSE, FALSE); CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
return FALSE; return FALSE;
} }
} }
RtlCopyMemory(Buffer, RtlCopyMemory(Buffer,
(char*)BaseAddress + ReadOffset % VACB_MAPPING_GRANULARITY, (char*)BaseAddress + ReadOffset % VACB_MAPPING_GRANULARITY,
TempLength); TempLength);
CcRosReleaseVacb(Bcb, Vacb, TRUE, FALSE, FALSE); CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
ReadLength += TempLength; ReadLength += TempLength;
Length -= TempLength; Length -= TempLength;
ReadOffset += TempLength; ReadOffset += TempLength;
@ -417,7 +418,7 @@ CcCopyRead (
while (Length > 0) while (Length > 0)
{ {
TempLength = min(VACB_MAPPING_GRANULARITY, Length); TempLength = min(VACB_MAPPING_GRANULARITY, Length);
Status = ReadVacbChain(Bcb, ReadOffset, TempLength, Buffer); Status = ReadVacbChain(SharedCacheMap, ReadOffset, TempLength, Buffer);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
IoStatus->Information = 0; IoStatus->Information = 0;
@ -454,7 +455,7 @@ CcCopyWrite (
NTSTATUS Status; NTSTATUS Status;
ULONG WriteOffset; ULONG WriteOffset;
KIRQL oldirql; KIRQL oldirql;
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
PROS_VACB Vacb; PROS_VACB Vacb;
ULONG TempLength; ULONG TempLength;
@ -465,26 +466,26 @@ CcCopyWrite (
"Length %lu, Wait %u, Buffer 0x%p)\n", "Length %lu, Wait %u, Buffer 0x%p)\n",
FileObject, FileOffset->QuadPart, Length, Wait, Buffer); FileObject, FileOffset->QuadPart, Length, Wait, Buffer);
Bcb = FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
WriteOffset = (ULONG)FileOffset->QuadPart; WriteOffset = (ULONG)FileOffset->QuadPart;
if (!Wait) if (!Wait)
{ {
/* testing, if the requested datas are available */ /* testing, if the requested datas are available */
KeAcquireSpinLock(&Bcb->BcbLock, &oldirql); KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldirql);
/* FIXME: this loop doesn't take into account areas that don't have /* FIXME: this loop doesn't take into account areas that don't have
* a VACB in the list yet */ * a VACB in the list yet */
current_entry = Bcb->BcbVacbListHead.Flink; current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
while (current_entry != &Bcb->BcbVacbListHead) while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
{ {
Vacb = CONTAINING_RECORD(current_entry, Vacb = CONTAINING_RECORD(current_entry,
ROS_VACB, ROS_VACB,
BcbVacbListEntry); CacheMapVacbListEntry);
if (!Vacb->Valid && if (!Vacb->Valid &&
DoRangesIntersect(Vacb->FileOffset, VACB_MAPPING_GRANULARITY, DoRangesIntersect(Vacb->FileOffset, VACB_MAPPING_GRANULARITY,
WriteOffset, Length)) WriteOffset, Length))
{ {
KeReleaseSpinLock(&Bcb->BcbLock, oldirql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
/* datas not available */ /* datas not available */
return FALSE; return FALSE;
} }
@ -492,7 +493,7 @@ CcCopyWrite (
break; break;
current_entry = current_entry->Flink; current_entry = current_entry->Flink;
} }
KeReleaseSpinLock(&Bcb->BcbLock, oldirql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
} }
TempLength = WriteOffset % VACB_MAPPING_GRANULARITY; TempLength = WriteOffset % VACB_MAPPING_GRANULARITY;
@ -501,7 +502,7 @@ CcCopyWrite (
ULONG ROffset; ULONG ROffset;
ROffset = ROUND_DOWN(WriteOffset, VACB_MAPPING_GRANULARITY); ROffset = ROUND_DOWN(WriteOffset, VACB_MAPPING_GRANULARITY);
TempLength = min(Length, VACB_MAPPING_GRANULARITY - TempLength); TempLength = min(Length, VACB_MAPPING_GRANULARITY - TempLength);
Status = CcRosRequestVacb(Bcb, ROffset, Status = CcRosRequestVacb(SharedCacheMap, ROffset,
&BaseAddress, &Valid, &Vacb); &BaseAddress, &Valid, &Vacb);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
@ -517,7 +518,7 @@ CcCopyWrite (
RtlCopyMemory((char*)BaseAddress + WriteOffset % VACB_MAPPING_GRANULARITY, RtlCopyMemory((char*)BaseAddress + WriteOffset % VACB_MAPPING_GRANULARITY,
Buffer, Buffer,
TempLength); TempLength);
CcRosReleaseVacb(Bcb, Vacb, TRUE, TRUE, FALSE); CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, TRUE, FALSE);
Length -= TempLength; Length -= TempLength;
WriteOffset += TempLength; WriteOffset += TempLength;
@ -528,7 +529,7 @@ CcCopyWrite (
while (Length > 0) while (Length > 0)
{ {
TempLength = min(VACB_MAPPING_GRANULARITY, Length); TempLength = min(VACB_MAPPING_GRANULARITY, Length);
Status = CcRosRequestVacb(Bcb, Status = CcRosRequestVacb(SharedCacheMap,
WriteOffset, WriteOffset,
&BaseAddress, &BaseAddress,
&Valid, &Valid,
@ -541,12 +542,12 @@ CcCopyWrite (
{ {
if (!NT_SUCCESS(CcReadVirtualAddress(Vacb))) if (!NT_SUCCESS(CcReadVirtualAddress(Vacb)))
{ {
CcRosReleaseVacb(Bcb, Vacb, FALSE, FALSE, FALSE); CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
return FALSE; return FALSE;
} }
} }
RtlCopyMemory(BaseAddress, Buffer, TempLength); RtlCopyMemory(BaseAddress, Buffer, TempLength);
CcRosReleaseVacb(Bcb, Vacb, TRUE, TRUE, FALSE); CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, TRUE, FALSE);
Length -= TempLength; Length -= TempLength;
WriteOffset += TempLength; WriteOffset += TempLength;
@ -684,29 +685,29 @@ CcZeroData (
{ {
/* File is cached */ /* File is cached */
KIRQL oldirql; KIRQL oldirql;
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
PROS_VACB Vacb, current, previous; PROS_VACB Vacb, current, previous;
ULONG TempLength; ULONG TempLength;
Bcb = FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
if (!Wait) if (!Wait)
{ {
/* testing, if the requested datas are available */ /* testing, if the requested datas are available */
KeAcquireSpinLock(&Bcb->BcbLock, &oldirql); KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldirql);
/* FIXME: this loop doesn't take into account areas that don't have /* FIXME: this loop doesn't take into account areas that don't have
* a VACB in the list yet */ * a VACB in the list yet */
current_entry = Bcb->BcbVacbListHead.Flink; current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
while (current_entry != &Bcb->BcbVacbListHead) while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
{ {
Vacb = CONTAINING_RECORD(current_entry, Vacb = CONTAINING_RECORD(current_entry,
ROS_VACB, ROS_VACB,
BcbVacbListEntry); CacheMapVacbListEntry);
if (!Vacb->Valid && if (!Vacb->Valid &&
DoRangesIntersect(Vacb->FileOffset, VACB_MAPPING_GRANULARITY, DoRangesIntersect(Vacb->FileOffset, VACB_MAPPING_GRANULARITY,
WriteOffset.u.LowPart, Length)) WriteOffset.u.LowPart, Length))
{ {
KeReleaseSpinLock(&Bcb->BcbLock, oldirql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
/* datas not available */ /* datas not available */
return FALSE; return FALSE;
} }
@ -714,7 +715,7 @@ CcZeroData (
break; break;
current_entry = current_entry->Flink; current_entry = current_entry->Flink;
} }
KeReleaseSpinLock(&Bcb->BcbLock, oldirql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
} }
while (Length > 0) while (Length > 0)
@ -729,7 +730,7 @@ CcZeroData (
{ {
CurrentLength = Length; CurrentLength = Length;
} }
Status = CcRosGetVacbChain(Bcb, WriteOffset.u.LowPart - Offset, Status = CcRosGetVacbChain(SharedCacheMap, WriteOffset.u.LowPart - Offset,
Offset + CurrentLength, &Vacb); Offset + CurrentLength, &Vacb);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
@ -774,7 +775,7 @@ CcZeroData (
{ {
previous = current; previous = current;
current = current->NextInChain; current = current->NextInChain;
CcRosReleaseVacb(Bcb, previous, TRUE, TRUE, FALSE); CcRosReleaseVacb(SharedCacheMap, previous, TRUE, TRUE, FALSE);
} }
} }
} }

48
reactos/ntoskrnl/cc/fs.c
View file

@ -52,7 +52,7 @@ CcGetFileObjectFromBcb (
IN PVOID Bcb) IN PVOID Bcb)
{ {
PINTERNAL_BCB iBcb = (PINTERNAL_BCB)Bcb; PINTERNAL_BCB iBcb = (PINTERNAL_BCB)Bcb;
return iBcb->Vacb->Bcb->FileObject; return iBcb->Vacb->SharedCacheMap->FileObject;
} }
/* /*
@ -128,7 +128,7 @@ CcSetFileSizes (
IN PCC_FILE_SIZES FileSizes) IN PCC_FILE_SIZES FileSizes)
{ {
KIRQL oldirql; KIRQL oldirql;
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
PROS_VACB current; PROS_VACB current;
LIST_ENTRY FreeListHead; LIST_ENTRY FreeListHead;
@ -141,33 +141,33 @@ CcSetFileSizes (
FileSizes->FileSize.QuadPart, FileSizes->FileSize.QuadPart,
FileSizes->ValidDataLength.QuadPart); FileSizes->ValidDataLength.QuadPart);
Bcb = FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
/* /*
* It is valid to call this function on file objects that weren't * It is valid to call this function on file objects that weren't
* initialized for caching. In this case it's simple no-op. * initialized for caching. In this case it's simple no-op.
*/ */
if (Bcb == NULL) if (SharedCacheMap == NULL)
return; return;
if (FileSizes->AllocationSize.QuadPart < Bcb->AllocationSize.QuadPart) if (FileSizes->AllocationSize.QuadPart < SharedCacheMap->AllocationSize.QuadPart)
{ {
InitializeListHead(&FreeListHead); InitializeListHead(&FreeListHead);
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
KeAcquireSpinLock(&Bcb->BcbLock, &oldirql); KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldirql);
current_entry = Bcb->BcbVacbListHead.Flink; current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
while (current_entry != &Bcb->BcbVacbListHead) while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
{ {
current = CONTAINING_RECORD(current_entry, current = CONTAINING_RECORD(current_entry,
ROS_VACB, ROS_VACB,
BcbVacbListEntry); CacheMapVacbListEntry);
current_entry = current_entry->Flink; current_entry = current_entry->Flink;
if (current->FileOffset >= FileSizes->AllocationSize.QuadPart) if (current->FileOffset >= FileSizes->AllocationSize.QuadPart)
{ {
if ((current->ReferenceCount == 0) || ((current->ReferenceCount == 1) && current->Dirty)) if ((current->ReferenceCount == 0) || ((current->ReferenceCount == 1) && current->Dirty))
{ {
RemoveEntryList(&current->BcbVacbListEntry); RemoveEntryList(&current->CacheMapVacbListEntry);
RemoveEntryList(&current->VacbListEntry); RemoveEntryList(&current->VacbListEntry);
RemoveEntryList(&current->VacbLruListEntry); RemoveEntryList(&current->VacbLruListEntry);
if (current->Dirty) if (current->Dirty)
@ -175,7 +175,7 @@ CcSetFileSizes (
RemoveEntryList(&current->DirtyVacbListEntry); RemoveEntryList(&current->DirtyVacbListEntry);
DirtyPageCount -= VACB_MAPPING_GRANULARITY / PAGE_SIZE; DirtyPageCount -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
} }
InsertHeadList(&FreeListHead, &current->BcbVacbListEntry); InsertHeadList(&FreeListHead, &current->CacheMapVacbListEntry);
} }
else else
{ {
@ -185,15 +185,15 @@ CcSetFileSizes (
} }
} }
Bcb->AllocationSize = FileSizes->AllocationSize; SharedCacheMap->AllocationSize = FileSizes->AllocationSize;
Bcb->FileSize = FileSizes->FileSize; SharedCacheMap->FileSize = FileSizes->FileSize;
KeReleaseSpinLock(&Bcb->BcbLock, oldirql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
current_entry = FreeListHead.Flink; current_entry = FreeListHead.Flink;
while(current_entry != &FreeListHead) while(current_entry != &FreeListHead)
{ {
current = CONTAINING_RECORD(current_entry, ROS_VACB, BcbVacbListEntry); current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
current_entry = current_entry->Flink; current_entry = current_entry->Flink;
Status = CcRosInternalFreeVacb(current); Status = CcRosInternalFreeVacb(current);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
@ -205,10 +205,10 @@ CcSetFileSizes (
} }
else else
{ {
KeAcquireSpinLock(&Bcb->BcbLock, &oldirql); KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldirql);
Bcb->AllocationSize = FileSizes->AllocationSize; SharedCacheMap->AllocationSize = FileSizes->AllocationSize;
Bcb->FileSize = FileSizes->FileSize; SharedCacheMap->FileSize = FileSizes->FileSize;
KeReleaseSpinLock(&Bcb->BcbLock, oldirql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
} }
} }
@ -249,14 +249,14 @@ CcGetFileSizes (
IN PFILE_OBJECT FileObject, IN PFILE_OBJECT FileObject,
IN PCC_FILE_SIZES FileSizes) IN PCC_FILE_SIZES FileSizes)
{ {
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
Bcb = FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
if (!Bcb) if (!SharedCacheMap)
return FALSE; return FALSE;
FileSizes->AllocationSize = Bcb->AllocationSize; FileSizes->AllocationSize = SharedCacheMap->AllocationSize;
FileSizes->FileSize = FileSizes->ValidDataLength = Bcb->FileSize; FileSizes->FileSize = FileSizes->ValidDataLength = SharedCacheMap->FileSize;
return TRUE; return TRUE;
} }

20
reactos/ntoskrnl/cc/pin.c
View file

@ -34,7 +34,7 @@ CcMapData (
{ {
ULONG ReadOffset; ULONG ReadOffset;
BOOLEAN Valid; BOOLEAN Valid;
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
PROS_VACB Vacb; PROS_VACB Vacb;
NTSTATUS Status; NTSTATUS Status;
PINTERNAL_BCB iBcb; PINTERNAL_BCB iBcb;
@ -50,12 +50,12 @@ CcMapData (
ASSERT(FileObject->SectionObjectPointer); ASSERT(FileObject->SectionObjectPointer);
ASSERT(FileObject->SectionObjectPointer->SharedCacheMap); ASSERT(FileObject->SectionObjectPointer->SharedCacheMap);
Bcb = FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
ASSERT(Bcb); ASSERT(SharedCacheMap);
DPRINT("AllocationSize %I64x, FileSize %I64x\n", DPRINT("AllocationSize %I64x, FileSize %I64x\n",
Bcb->AllocationSize.QuadPart, SharedCacheMap->AllocationSize.QuadPart,
Bcb->FileSize.QuadPart); SharedCacheMap->FileSize.QuadPart);
if (ReadOffset % VACB_MAPPING_GRANULARITY + Length > VACB_MAPPING_GRANULARITY) if (ReadOffset % VACB_MAPPING_GRANULARITY + Length > VACB_MAPPING_GRANULARITY)
{ {
@ -63,7 +63,7 @@ CcMapData (
} }
ROffset = ROUND_DOWN(ReadOffset, VACB_MAPPING_GRANULARITY); ROffset = ROUND_DOWN(ReadOffset, VACB_MAPPING_GRANULARITY);
Status = CcRosRequestVacb(Bcb, Status = CcRosRequestVacb(SharedCacheMap,
ROffset, ROffset,
pBuffer, pBuffer,
&Valid, &Valid,
@ -77,13 +77,13 @@ CcMapData (
{ {
if (!(Flags & MAP_WAIT)) if (!(Flags & MAP_WAIT))
{ {
CcRosReleaseVacb(Bcb, Vacb, FALSE, FALSE, FALSE); CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
return FALSE; return FALSE;
} }
if (!NT_SUCCESS(CcReadVirtualAddress(Vacb))) if (!NT_SUCCESS(CcReadVirtualAddress(Vacb)))
{ {
CcRosReleaseVacb(Bcb, Vacb, FALSE, FALSE, FALSE); CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
return FALSE; return FALSE;
} }
} }
@ -92,7 +92,7 @@ CcMapData (
iBcb = ExAllocateFromNPagedLookasideList(&iBcbLookasideList); iBcb = ExAllocateFromNPagedLookasideList(&iBcbLookasideList);
if (iBcb == NULL) if (iBcb == NULL)
{ {
CcRosReleaseVacb(Bcb, Vacb, TRUE, FALSE, FALSE); CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
return FALSE; return FALSE;
} }
@ -195,7 +195,7 @@ CcUnpinData (
{ {
PINTERNAL_BCB iBcb = Bcb; PINTERNAL_BCB iBcb = Bcb;
CcRosReleaseVacb(iBcb->Vacb->Bcb, CcRosReleaseVacb(iBcb->Vacb->SharedCacheMap,
iBcb->Vacb, iBcb->Vacb,
TRUE, TRUE,
iBcb->Dirty, iBcb->Dirty,

346
reactos/ntoskrnl/cc/view.c
View file

@ -49,14 +49,14 @@ ULONG DirtyPageCount = 0;
KGUARDED_MUTEX ViewLock; KGUARDED_MUTEX ViewLock;
NPAGED_LOOKASIDE_LIST iBcbLookasideList; NPAGED_LOOKASIDE_LIST iBcbLookasideList;
static NPAGED_LOOKASIDE_LIST BcbLookasideList; static NPAGED_LOOKASIDE_LIST SharedCacheMapLookasideList;
static NPAGED_LOOKASIDE_LIST VacbLookasideList; static NPAGED_LOOKASIDE_LIST VacbLookasideList;
#if DBG #if DBG
static void CcRosVacbIncRefCount_(PROS_VACB vacb, const char* file, int line) static void CcRosVacbIncRefCount_(PROS_VACB vacb, const char* file, int line)
{ {
++vacb->ReferenceCount; ++vacb->ReferenceCount;
if (vacb->Bcb->Trace) if (vacb->SharedCacheMap->Trace)
{ {
DbgPrint("(%s:%i) VACB %p ++RefCount=%lu, Dirty %u, PageOut %lu\n", DbgPrint("(%s:%i) VACB %p ++RefCount=%lu, Dirty %u, PageOut %lu\n",
file, line, vacb, vacb->ReferenceCount, vacb->Dirty, vacb->PageOut); file, line, vacb, vacb->ReferenceCount, vacb->Dirty, vacb->PageOut);
@ -65,7 +65,7 @@ static void CcRosVacbIncRefCount_(PROS_VACB vacb, const char* file, int line)
static void CcRosVacbDecRefCount_(PROS_VACB vacb, const char* file, int line) static void CcRosVacbDecRefCount_(PROS_VACB vacb, const char* file, int line)
{ {
--vacb->ReferenceCount; --vacb->ReferenceCount;
if (vacb->Bcb->Trace) if (vacb->SharedCacheMap->Trace)
{ {
DbgPrint("(%s:%i) VACB %p --RefCount=%lu, Dirty %u, PageOut %lu\n", DbgPrint("(%s:%i) VACB %p --RefCount=%lu, Dirty %u, PageOut %lu\n",
file, line, vacb, vacb->ReferenceCount, vacb->Dirty, vacb->PageOut); file, line, vacb, vacb->ReferenceCount, vacb->Dirty, vacb->PageOut);
@ -87,7 +87,7 @@ CcRosInternalFreeVacb(PROS_VACB Vacb);
VOID VOID
NTAPI NTAPI
CcRosTraceCacheMap ( CcRosTraceCacheMap (
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
BOOLEAN Trace ) BOOLEAN Trace )
{ {
#if DBG #if DBG
@ -95,38 +95,38 @@ CcRosTraceCacheMap (
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
PROS_VACB current; PROS_VACB current;
if ( !Bcb ) if (!SharedCacheMap)
return; 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); KeAcquireGuardedMutex(&ViewLock);
KeAcquireSpinLock(&Bcb->BcbLock, &oldirql); KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldirql);
current_entry = Bcb->BcbVacbListHead.Flink; current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
while (current_entry != &Bcb->BcbVacbListHead) 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; current_entry = current_entry->Flink;
DPRINT1(" VACB 0x%p enabled, RefCount %lu, Dirty %u, PageOut %lu\n", DPRINT1(" VACB 0x%p enabled, RefCount %lu, Dirty %u, PageOut %lu\n",
current, current->ReferenceCount, current->Dirty, current->PageOut ); current, current->ReferenceCount, current->Dirty, current->PageOut );
} }
KeReleaseSpinLock(&Bcb->BcbLock, oldirql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
} }
else else
{ {
DPRINT1("Disabling Tracing for CacheMap 0x%p:\n", Bcb ); DPRINT1("Disabling Tracing for CacheMap 0x%p:\n", SharedCacheMap);
} }
#else #else
Bcb = Bcb; UNREFERENCED_PARAMETER(SharedCacheMap);
Trace = Trace; UNREFERENCED_PARAMETER(Trace);
#endif #endif
} }
@ -142,14 +142,14 @@ CcRosFlushVacb (
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
KeAcquireSpinLock(&Vacb->Bcb->BcbLock, &oldIrql); KeAcquireSpinLock(&Vacb->SharedCacheMap->CacheMapLock, &oldIrql);
Vacb->Dirty = FALSE; Vacb->Dirty = FALSE;
RemoveEntryList(&Vacb->DirtyVacbListEntry); RemoveEntryList(&Vacb->DirtyVacbListEntry);
DirtyPageCount -= VACB_MAPPING_GRANULARITY / PAGE_SIZE; DirtyPageCount -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
CcRosVacbDecRefCount(Vacb); CcRosVacbDecRefCount(Vacb);
KeReleaseSpinLock(&Vacb->Bcb->BcbLock, oldIrql); KeReleaseSpinLock(&Vacb->SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
} }
@ -192,8 +192,8 @@ CcRosFlushDirtyPages (
CcRosVacbIncRefCount(current); CcRosVacbIncRefCount(current);
Locked = current->Bcb->Callbacks->AcquireForLazyWrite( Locked = current->SharedCacheMap->Callbacks->AcquireForLazyWrite(
current->Bcb->LazyWriteContext, Wait); current->SharedCacheMap->LazyWriteContext, Wait);
if (!Locked) if (!Locked)
{ {
CcRosVacbDecRefCount(current); CcRosVacbDecRefCount(current);
@ -207,8 +207,8 @@ CcRosFlushDirtyPages (
Wait ? NULL : &ZeroTimeout); Wait ? NULL : &ZeroTimeout);
if (Status != STATUS_SUCCESS) if (Status != STATUS_SUCCESS)
{ {
current->Bcb->Callbacks->ReleaseFromLazyWrite( current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
current->Bcb->LazyWriteContext); current->SharedCacheMap->LazyWriteContext);
CcRosVacbDecRefCount(current); CcRosVacbDecRefCount(current);
continue; continue;
} }
@ -219,8 +219,8 @@ CcRosFlushDirtyPages (
if (current->ReferenceCount > 2) if (current->ReferenceCount > 2)
{ {
KeReleaseMutex(&current->Mutex, FALSE); KeReleaseMutex(&current->Mutex, FALSE);
current->Bcb->Callbacks->ReleaseFromLazyWrite( current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
current->Bcb->LazyWriteContext); current->SharedCacheMap->LazyWriteContext);
CcRosVacbDecRefCount(current); CcRosVacbDecRefCount(current);
continue; continue;
} }
@ -230,8 +230,8 @@ CcRosFlushDirtyPages (
Status = CcRosFlushVacb(current); Status = CcRosFlushVacb(current);
KeReleaseMutex(&current->Mutex, FALSE); KeReleaseMutex(&current->Mutex, FALSE);
current->Bcb->Callbacks->ReleaseFromLazyWrite( current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
current->Bcb->LazyWriteContext); current->SharedCacheMap->LazyWriteContext);
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
CcRosVacbDecRefCount(current); CcRosVacbDecRefCount(current);
@ -296,7 +296,7 @@ retry:
VacbLruListEntry); VacbLruListEntry);
current_entry = current_entry->Flink; current_entry = current_entry->Flink;
KeAcquireSpinLock(&current->Bcb->BcbLock, &oldIrql); KeAcquireSpinLock(&current->SharedCacheMap->CacheMapLock, &oldIrql);
/* Reference the VACB */ /* Reference the VACB */
CcRosVacbIncRefCount(current); CcRosVacbIncRefCount(current);
@ -305,7 +305,7 @@ retry:
if (current->MappedCount > 0 && !current->Dirty) if (current->MappedCount > 0 && !current->Dirty)
{ {
/* We have to break these locks because Cc sucks */ /* We have to break these locks because Cc sucks */
KeReleaseSpinLock(&current->Bcb->BcbLock, oldIrql); KeReleaseSpinLock(&current->SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
/* Page out the VACB */ /* Page out the VACB */
@ -318,7 +318,7 @@ retry:
/* Reacquire the locks */ /* Reacquire the locks */
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
KeAcquireSpinLock(&current->Bcb->BcbLock, &oldIrql); KeAcquireSpinLock(&current->SharedCacheMap->CacheMapLock, &oldIrql);
} }
/* Dereference the VACB */ /* Dereference the VACB */
@ -330,10 +330,10 @@ retry:
ASSERT(!current->Dirty); ASSERT(!current->Dirty);
ASSERT(!current->MappedCount); ASSERT(!current->MappedCount);
RemoveEntryList(&current->BcbVacbListEntry); RemoveEntryList(&current->CacheMapVacbListEntry);
RemoveEntryList(&current->VacbListEntry); RemoveEntryList(&current->VacbListEntry);
RemoveEntryList(&current->VacbLruListEntry); RemoveEntryList(&current->VacbLruListEntry);
InsertHeadList(&FreeList, &current->BcbVacbListEntry); InsertHeadList(&FreeList, &current->CacheMapVacbListEntry);
/* Calculate how many pages we freed for Mm */ /* Calculate how many pages we freed for Mm */
PagesFreed = min(VACB_MAPPING_GRANULARITY / PAGE_SIZE, Target); PagesFreed = min(VACB_MAPPING_GRANULARITY / PAGE_SIZE, Target);
@ -341,7 +341,7 @@ retry:
(*NrFreed) += PagesFreed; (*NrFreed) += PagesFreed;
} }
KeReleaseSpinLock(&current->Bcb->BcbLock, oldIrql); KeReleaseSpinLock(&current->SharedCacheMap->CacheMapLock, oldIrql);
} }
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
@ -370,7 +370,7 @@ retry:
current_entry = RemoveHeadList(&FreeList); current_entry = RemoveHeadList(&FreeList);
current = CONTAINING_RECORD(current_entry, current = CONTAINING_RECORD(current_entry,
ROS_VACB, ROS_VACB,
BcbVacbListEntry); CacheMapVacbListEntry);
CcRosInternalFreeVacb(current); CcRosInternalFreeVacb(current);
} }
@ -382,7 +382,7 @@ retry:
NTSTATUS NTSTATUS
NTAPI NTAPI
CcRosReleaseVacb ( CcRosReleaseVacb (
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
PROS_VACB Vacb, PROS_VACB Vacb,
BOOLEAN Valid, BOOLEAN Valid,
BOOLEAN Dirty, BOOLEAN Dirty,
@ -391,13 +391,13 @@ CcRosReleaseVacb (
BOOLEAN WasDirty; BOOLEAN WasDirty;
KIRQL oldIrql; KIRQL oldIrql;
ASSERT(Bcb); ASSERT(SharedCacheMap);
DPRINT("CcRosReleaseVacb(Bcb 0x%p, Vacb 0x%p, Valid %u)\n", DPRINT("CcRosReleaseVacb(SharedCacheMap 0x%p, Vacb 0x%p, Valid %u)\n",
Bcb, Vacb, Valid); SharedCacheMap, Vacb, Valid);
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql); KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
Vacb->Valid = Valid; Vacb->Valid = Valid;
@ -424,7 +424,7 @@ CcRosReleaseVacb (
CcRosVacbIncRefCount(Vacb); CcRosVacbIncRefCount(Vacb);
} }
KeReleaseSpinLock(&Bcb->BcbLock, oldIrql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
KeReleaseMutex(&Vacb->Mutex, FALSE); KeReleaseMutex(&Vacb->Mutex, FALSE);
@ -435,31 +435,32 @@ CcRosReleaseVacb (
PROS_VACB PROS_VACB
NTAPI NTAPI
CcRosLookupVacb ( CcRosLookupVacb (
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
ULONG FileOffset) ULONG FileOffset)
{ {
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
PROS_VACB current; PROS_VACB current;
KIRQL oldIrql; KIRQL oldIrql;
ASSERT(Bcb); ASSERT(SharedCacheMap);
DPRINT("CcRosLookupVacb(Bcb -x%p, FileOffset %lu)\n", Bcb, FileOffset); DPRINT("CcRosLookupVacb(SharedCacheMap 0x%p, FileOffset %lu)\n",
SharedCacheMap, FileOffset);
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql); KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
current_entry = Bcb->BcbVacbListHead.Flink; current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
while (current_entry != &Bcb->BcbVacbListHead) while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
{ {
current = CONTAINING_RECORD(current_entry, current = CONTAINING_RECORD(current_entry,
ROS_VACB, ROS_VACB,
BcbVacbListEntry); CacheMapVacbListEntry);
if (IsPointInRange(current->FileOffset, VACB_MAPPING_GRANULARITY, if (IsPointInRange(current->FileOffset, VACB_MAPPING_GRANULARITY,
FileOffset)) FileOffset))
{ {
CcRosVacbIncRefCount(current); CcRosVacbIncRefCount(current);
KeReleaseSpinLock(&Bcb->BcbLock, oldIrql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
KeWaitForSingleObject(&current->Mutex, KeWaitForSingleObject(&current->Mutex,
Executive, Executive,
@ -473,7 +474,7 @@ CcRosLookupVacb (
current_entry = current_entry->Flink; current_entry = current_entry->Flink;
} }
KeReleaseSpinLock(&Bcb->BcbLock, oldIrql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
return NULL; return NULL;
@ -482,24 +483,25 @@ CcRosLookupVacb (
NTSTATUS NTSTATUS
NTAPI NTAPI
CcRosMarkDirtyVacb ( CcRosMarkDirtyVacb (
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
ULONG FileOffset) ULONG FileOffset)
{ {
PROS_VACB Vacb; PROS_VACB Vacb;
KIRQL oldIrql; KIRQL oldIrql;
ASSERT(Bcb); ASSERT(SharedCacheMap);
DPRINT("CcRosMarkDirtyVacb(Bcb 0x%p, FileOffset %lu)\n", Bcb, FileOffset); DPRINT("CcRosMarkDirtyVacb(SharedCacheMap 0x%p, FileOffset %lu)\n",
SharedCacheMap, FileOffset);
Vacb = CcRosLookupVacb(Bcb, FileOffset); Vacb = CcRosLookupVacb(SharedCacheMap, FileOffset);
if (Vacb == NULL) if (Vacb == NULL)
{ {
KeBugCheck(CACHE_MANAGER); KeBugCheck(CACHE_MANAGER);
} }
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql); KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
if (!Vacb->Dirty) if (!Vacb->Dirty)
{ {
@ -517,7 +519,7 @@ CcRosMarkDirtyVacb (
Vacb->Dirty = TRUE; Vacb->Dirty = TRUE;
KeReleaseSpinLock(&Bcb->BcbLock, oldIrql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
KeReleaseMutex(&Vacb->Mutex, FALSE); KeReleaseMutex(&Vacb->Mutex, FALSE);
@ -527,7 +529,7 @@ CcRosMarkDirtyVacb (
NTSTATUS NTSTATUS
NTAPI NTAPI
CcRosUnmapVacb ( CcRosUnmapVacb (
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
ULONG FileOffset, ULONG FileOffset,
BOOLEAN NowDirty) BOOLEAN NowDirty)
{ {
@ -535,19 +537,19 @@ CcRosUnmapVacb (
BOOLEAN WasDirty; BOOLEAN WasDirty;
KIRQL oldIrql; KIRQL oldIrql;
ASSERT(Bcb); ASSERT(SharedCacheMap);
DPRINT("CcRosUnmapVacb(Bcb 0x%p, FileOffset %lu, NowDirty %u)\n", DPRINT("CcRosUnmapVacb(SharedCacheMap 0x%p, FileOffset %lu, NowDirty %u)\n",
Bcb, FileOffset, NowDirty); SharedCacheMap, FileOffset, NowDirty);
Vacb = CcRosLookupVacb(Bcb, FileOffset); Vacb = CcRosLookupVacb(SharedCacheMap, FileOffset);
if (Vacb == NULL) if (Vacb == NULL)
{ {
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql); KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
WasDirty = Vacb->Dirty; WasDirty = Vacb->Dirty;
Vacb->Dirty = Vacb->Dirty || NowDirty; Vacb->Dirty = Vacb->Dirty || NowDirty;
@ -570,7 +572,7 @@ CcRosUnmapVacb (
CcRosVacbDecRefCount(Vacb); CcRosVacbDecRefCount(Vacb);
} }
KeReleaseSpinLock(&Bcb->BcbLock, oldIrql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
KeReleaseMutex(&Vacb->Mutex, FALSE); KeReleaseMutex(&Vacb->Mutex, FALSE);
@ -580,7 +582,7 @@ CcRosUnmapVacb (
static static
NTSTATUS NTSTATUS
CcRosCreateVacb ( CcRosCreateVacb (
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
ULONG FileOffset, ULONG FileOffset,
PROS_VACB *Vacb) PROS_VACB *Vacb)
{ {
@ -590,11 +592,11 @@ CcRosCreateVacb (
NTSTATUS Status; NTSTATUS Status;
KIRQL oldIrql; KIRQL oldIrql;
ASSERT(Bcb); ASSERT(SharedCacheMap);
DPRINT("CcRosCreateVacb()\n"); DPRINT("CcRosCreateVacb()\n");
if (FileOffset >= Bcb->FileSize.u.LowPart) if (FileOffset >= SharedCacheMap->FileSize.u.LowPart)
{ {
*Vacb = NULL; *Vacb = NULL;
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
@ -605,11 +607,11 @@ CcRosCreateVacb (
current->Dirty = FALSE; current->Dirty = FALSE;
current->PageOut = FALSE; current->PageOut = FALSE;
current->FileOffset = ROUND_DOWN(FileOffset, VACB_MAPPING_GRANULARITY); current->FileOffset = ROUND_DOWN(FileOffset, VACB_MAPPING_GRANULARITY);
current->Bcb = Bcb; current->SharedCacheMap = SharedCacheMap;
#if DBG #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 #endif
current->MappedCount = 0; current->MappedCount = 0;
@ -630,26 +632,26 @@ CcRosCreateVacb (
* file offset exist. If there is a VACB, we release * file offset exist. If there is a VACB, we release
* our newly created VACB and return the existing one. * our newly created VACB and return the existing one.
*/ */
KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql); KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
current_entry = Bcb->BcbVacbListHead.Flink; current_entry = SharedCacheMap->CacheMapVacbListHead.Flink;
previous = NULL; previous = NULL;
while (current_entry != &Bcb->BcbVacbListHead) while (current_entry != &SharedCacheMap->CacheMapVacbListHead)
{ {
current = CONTAINING_RECORD(current_entry, current = CONTAINING_RECORD(current_entry,
ROS_VACB, ROS_VACB,
BcbVacbListEntry); CacheMapVacbListEntry);
if (IsPointInRange(current->FileOffset, VACB_MAPPING_GRANULARITY, if (IsPointInRange(current->FileOffset, VACB_MAPPING_GRANULARITY,
FileOffset)) FileOffset))
{ {
CcRosVacbIncRefCount(current); CcRosVacbIncRefCount(current);
KeReleaseSpinLock(&Bcb->BcbLock, oldIrql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
#if DBG #if DBG
if ( Bcb->Trace ) if (SharedCacheMap->Trace)
{ {
DPRINT1("CacheMap 0x%p: deleting newly created VACB 0x%p ( found existing one 0x%p )\n", DPRINT1("CacheMap 0x%p: deleting newly created VACB 0x%p ( found existing one 0x%p )\n",
Bcb, SharedCacheMap,
(*Vacb), (*Vacb),
current ); current);
} }
#endif #endif
KeReleaseMutex(&(*Vacb)->Mutex, FALSE); KeReleaseMutex(&(*Vacb)->Mutex, FALSE);
@ -677,13 +679,13 @@ CcRosCreateVacb (
current = *Vacb; current = *Vacb;
if (previous) if (previous)
{ {
InsertHeadList(&previous->BcbVacbListEntry, &current->BcbVacbListEntry); InsertHeadList(&previous->CacheMapVacbListEntry, &current->CacheMapVacbListEntry);
} }
else else
{ {
InsertHeadList(&Bcb->BcbVacbListHead, &current->BcbVacbListEntry); InsertHeadList(&SharedCacheMap->CacheMapVacbListHead, &current->CacheMapVacbListEntry);
} }
KeReleaseSpinLock(&Bcb->BcbLock, oldIrql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
InsertTailList(&VacbListHead, &current->VacbListEntry); InsertTailList(&VacbListHead, &current->VacbListEntry);
InsertTailList(&VacbLruListHead, &current->VacbLruListEntry); InsertTailList(&VacbLruListHead, &current->VacbLruListEntry);
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
@ -710,9 +712,9 @@ CcRosCreateVacb (
#if MI_TRACE_PFNS #if MI_TRACE_PFNS
PWCHAR pos = NULL; PWCHAR pos = NULL;
ULONG len = 0; ULONG len = 0;
if ((Bcb->FileObject) && (Bcb->FileObject->FileName.Buffer)) if ((SharedCacheMap->FileObject) && (SharedCacheMap->FileObject->FileName.Buffer))
{ {
pos = wcsrchr(Bcb->FileObject->FileName.Buffer, '\\'); pos = wcsrchr(SharedCacheMap->FileObject->FileName.Buffer, '\\');
len = wcslen(pos) * sizeof(WCHAR); len = wcslen(pos) * sizeof(WCHAR);
if (pos) snprintf(MI_PFN_CURRENT_PROCESS_NAME, min(16, len), "%S", pos); if (pos) snprintf(MI_PFN_CURRENT_PROCESS_NAME, min(16, len), "%S", pos);
} }
@ -727,7 +729,7 @@ CcRosCreateVacb (
NTSTATUS NTSTATUS
NTAPI NTAPI
CcRosGetVacbChain ( CcRosGetVacbChain (
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
ULONG FileOffset, ULONG FileOffset,
ULONG Length, ULONG Length,
PROS_VACB *Vacb) PROS_VACB *Vacb)
@ -737,7 +739,7 @@ CcRosGetVacbChain (
PROS_VACB *VacbList; PROS_VACB *VacbList;
PROS_VACB Previous = NULL; PROS_VACB Previous = NULL;
ASSERT(Bcb); ASSERT(SharedCacheMap);
DPRINT("CcRosGetVacbChain()\n"); DPRINT("CcRosGetVacbChain()\n");
@ -752,7 +754,7 @@ CcRosGetVacbChain (
for (i = 0; i < (Length / VACB_MAPPING_GRANULARITY); i++) for (i = 0; i < (Length / VACB_MAPPING_GRANULARITY); i++)
{ {
ULONG CurrentOffset = FileOffset + (i * VACB_MAPPING_GRANULARITY); ULONG CurrentOffset = FileOffset + (i * VACB_MAPPING_GRANULARITY);
current = CcRosLookupVacb(Bcb, CurrentOffset); current = CcRosLookupVacb(SharedCacheMap, CurrentOffset);
if (current != NULL) if (current != NULL)
{ {
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
@ -767,7 +769,7 @@ CcRosGetVacbChain (
} }
else else
{ {
CcRosCreateVacb(Bcb, CurrentOffset, &current); CcRosCreateVacb(SharedCacheMap, CurrentOffset, &current);
VacbList[i] = current; VacbList[i] = current;
} }
} }
@ -794,7 +796,7 @@ CcRosGetVacbChain (
NTSTATUS NTSTATUS
NTAPI NTAPI
CcRosGetVacb ( CcRosGetVacb (
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
ULONG FileOffset, ULONG FileOffset,
PULONG BaseOffset, PULONG BaseOffset,
PVOID* BaseAddress, PVOID* BaseAddress,
@ -804,20 +806,20 @@ CcRosGetVacb (
PROS_VACB current; PROS_VACB current;
NTSTATUS Status; NTSTATUS Status;
ASSERT(Bcb); ASSERT(SharedCacheMap);
DPRINT("CcRosGetVacb()\n"); DPRINT("CcRosGetVacb()\n");
/* /*
* Look for a VACB already mapping the same data. * Look for a VACB already mapping the same data.
*/ */
current = CcRosLookupVacb(Bcb, FileOffset); current = CcRosLookupVacb(SharedCacheMap, FileOffset);
if (current == NULL) if (current == NULL)
{ {
/* /*
* Otherwise create a new VACB. * Otherwise create a new VACB.
*/ */
Status = CcRosCreateVacb(Bcb, FileOffset, &current); Status = CcRosCreateVacb(SharedCacheMap, FileOffset, &current);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
return Status; return Status;
@ -846,18 +848,18 @@ CcRosGetVacb (
NTSTATUS NTSTATUS
NTAPI NTAPI
CcRosRequestVacb ( CcRosRequestVacb (
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
ULONG FileOffset, ULONG FileOffset,
PVOID* BaseAddress, PVOID* BaseAddress,
PBOOLEAN UptoDate, PBOOLEAN UptoDate,
PROS_VACB *Vacb) PROS_VACB *Vacb)
/* /*
* FUNCTION: Request a page mapping for a BCB * FUNCTION: Request a page mapping for a shared cache map
*/ */
{ {
ULONG BaseOffset; ULONG BaseOffset;
ASSERT(Bcb); ASSERT(SharedCacheMap);
if (FileOffset % VACB_MAPPING_GRANULARITY != 0) if (FileOffset % VACB_MAPPING_GRANULARITY != 0)
{ {
@ -866,7 +868,7 @@ CcRosRequestVacb (
KeBugCheck(CACHE_MANAGER); KeBugCheck(CACHE_MANAGER);
} }
return CcRosGetVacb(Bcb, return CcRosGetVacb(SharedCacheMap,
FileOffset, FileOffset,
&BaseOffset, &BaseOffset,
BaseAddress, BaseAddress,
@ -896,14 +898,14 @@ NTSTATUS
CcRosInternalFreeVacb ( CcRosInternalFreeVacb (
PROS_VACB Vacb) 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); DPRINT("Freeing VACB 0x%p\n", Vacb);
#if DBG #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 #endif
@ -929,7 +931,7 @@ CcFlushCache (
IN ULONG Length, IN ULONG Length,
OUT PIO_STATUS_BLOCK IoStatus) OUT PIO_STATUS_BLOCK IoStatus)
{ {
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
LARGE_INTEGER Offset; LARGE_INTEGER Offset;
PROS_VACB current; PROS_VACB current;
NTSTATUS Status; NTSTATUS Status;
@ -940,8 +942,8 @@ CcFlushCache (
if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap) if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
{ {
Bcb = (PBCB)SectionObjectPointers->SharedCacheMap; SharedCacheMap = SectionObjectPointers->SharedCacheMap;
ASSERT(Bcb); ASSERT(SharedCacheMap);
if (FileOffset) if (FileOffset)
{ {
Offset = *FileOffset; Offset = *FileOffset;
@ -949,7 +951,7 @@ CcFlushCache (
else else
{ {
Offset.QuadPart = (LONGLONG)0; Offset.QuadPart = (LONGLONG)0;
Length = Bcb->FileSize.u.LowPart; Length = SharedCacheMap->FileSize.u.LowPart;
} }
if (IoStatus) if (IoStatus)
@ -960,7 +962,7 @@ CcFlushCache (
while (Length > 0) while (Length > 0)
{ {
current = CcRosLookupVacb(Bcb, Offset.u.LowPart); current = CcRosLookupVacb(SharedCacheMap, Offset.u.LowPart);
if (current != NULL) if (current != NULL)
{ {
if (current->Dirty) if (current->Dirty)
@ -974,9 +976,9 @@ CcFlushCache (
KeReleaseMutex(&current->Mutex, FALSE); KeReleaseMutex(&current->Mutex, FALSE);
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql); KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
CcRosVacbDecRefCount(current); CcRosVacbDecRefCount(current);
KeReleaseSpinLock(&Bcb->BcbLock, oldIrql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
} }
@ -1004,9 +1006,9 @@ NTSTATUS
NTAPI NTAPI
CcRosDeleteFileCache ( CcRosDeleteFileCache (
PFILE_OBJECT FileObject, 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; PLIST_ENTRY current_entry;
@ -1014,16 +1016,16 @@ CcRosDeleteFileCache (
LIST_ENTRY FreeList; LIST_ENTRY FreeList;
KIRQL oldIrql; KIRQL oldIrql;
ASSERT(Bcb); ASSERT(SharedCacheMap);
Bcb->RefCount++; SharedCacheMap->RefCount++;
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
CcFlushCache(FileObject->SectionObjectPointer, NULL, 0, NULL); CcFlushCache(FileObject->SectionObjectPointer, NULL, 0, NULL);
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
Bcb->RefCount--; SharedCacheMap->RefCount--;
if (Bcb->RefCount == 0) if (SharedCacheMap->RefCount == 0)
{ {
FileObject->SectionObjectPointer->SharedCacheMap = NULL; FileObject->SectionObjectPointer->SharedCacheMap = NULL;
@ -1031,11 +1033,11 @@ CcRosDeleteFileCache (
* Release all VACBs * Release all VACBs
*/ */
InitializeListHead(&FreeList); InitializeListHead(&FreeList);
KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql); KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
while (!IsListEmpty(&Bcb->BcbVacbListHead)) while (!IsListEmpty(&SharedCacheMap->CacheMapVacbListHead))
{ {
current_entry = RemoveTailList(&Bcb->BcbVacbListHead); current_entry = RemoveTailList(&SharedCacheMap->CacheMapVacbListHead);
current = CONTAINING_RECORD(current_entry, ROS_VACB, BcbVacbListEntry); current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
RemoveEntryList(&current->VacbListEntry); RemoveEntryList(&current->VacbListEntry);
RemoveEntryList(&current->VacbLruListEntry); RemoveEntryList(&current->VacbLruListEntry);
if (current->Dirty) if (current->Dirty)
@ -1044,23 +1046,23 @@ CcRosDeleteFileCache (
DirtyPageCount -= VACB_MAPPING_GRANULARITY / PAGE_SIZE; DirtyPageCount -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
DPRINT1("Freeing dirty VACB\n"); DPRINT1("Freeing dirty VACB\n");
} }
InsertHeadList(&FreeList, &current->BcbVacbListEntry); InsertHeadList(&FreeList, &current->CacheMapVacbListEntry);
} }
#if DBG #if DBG
Bcb->Trace = FALSE; SharedCacheMap->Trace = FALSE;
#endif #endif
KeReleaseSpinLock(&Bcb->BcbLock, oldIrql); KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
ObDereferenceObject (Bcb->FileObject); ObDereferenceObject(SharedCacheMap->FileObject);
while (!IsListEmpty(&FreeList)) while (!IsListEmpty(&FreeList))
{ {
current_entry = RemoveTailList(&FreeList); current_entry = RemoveTailList(&FreeList);
current = CONTAINING_RECORD(current_entry, ROS_VACB, BcbVacbListEntry); current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
CcRosInternalFreeVacb(current); CcRosInternalFreeVacb(current);
} }
ExFreeToNPagedLookasideList(&BcbLookasideList, Bcb); ExFreeToNPagedLookasideList(&SharedCacheMapLookasideList, SharedCacheMap);
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
} }
return STATUS_SUCCESS; return STATUS_SUCCESS;
@ -1071,12 +1073,12 @@ NTAPI
CcRosReferenceCache ( CcRosReferenceCache (
PFILE_OBJECT FileObject) PFILE_OBJECT FileObject)
{ {
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
Bcb = (PBCB)FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
ASSERT(Bcb); ASSERT(SharedCacheMap);
ASSERT(Bcb->RefCount != 0); ASSERT(SharedCacheMap->RefCount != 0);
Bcb->RefCount++; SharedCacheMap->RefCount++;
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
} }
@ -1085,13 +1087,13 @@ NTAPI
CcRosRemoveIfClosed ( CcRosRemoveIfClosed (
PSECTION_OBJECT_POINTERS SectionObjectPointer) PSECTION_OBJECT_POINTERS SectionObjectPointer)
{ {
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
DPRINT("CcRosRemoveIfClosed()\n"); DPRINT("CcRosRemoveIfClosed()\n");
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
Bcb = (PBCB)SectionObjectPointer->SharedCacheMap; SharedCacheMap = SectionObjectPointer->SharedCacheMap;
if (Bcb && Bcb->RefCount == 0) if (SharedCacheMap && SharedCacheMap->RefCount == 0)
{ {
CcRosDeleteFileCache(Bcb->FileObject, Bcb); CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap);
} }
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
} }
@ -1102,17 +1104,17 @@ NTAPI
CcRosDereferenceCache ( CcRosDereferenceCache (
PFILE_OBJECT FileObject) PFILE_OBJECT FileObject)
{ {
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
Bcb = (PBCB)FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
ASSERT(Bcb); ASSERT(SharedCacheMap);
if (Bcb->RefCount > 0) if (SharedCacheMap->RefCount > 0)
{ {
Bcb->RefCount--; SharedCacheMap->RefCount--;
if (Bcb->RefCount == 0) if (SharedCacheMap->RefCount == 0)
{ {
MmFreeSectionSegments(Bcb->FileObject); MmFreeSectionSegments(SharedCacheMap->FileObject);
CcRosDeleteFileCache(FileObject, Bcb); CcRosDeleteFileCache(FileObject, SharedCacheMap);
} }
} }
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
@ -1127,23 +1129,23 @@ CcRosReleaseFileCache (
* has been closed. * has been closed.
*/ */
{ {
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
if (FileObject->SectionObjectPointer->SharedCacheMap != NULL) if (FileObject->SectionObjectPointer->SharedCacheMap != NULL)
{ {
Bcb = FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
if (FileObject->PrivateCacheMap != NULL) if (FileObject->PrivateCacheMap != NULL)
{ {
FileObject->PrivateCacheMap = NULL; FileObject->PrivateCacheMap = NULL;
if (Bcb->RefCount > 0) if (SharedCacheMap->RefCount > 0)
{ {
Bcb->RefCount--; SharedCacheMap->RefCount--;
if (Bcb->RefCount == 0) if (SharedCacheMap->RefCount == 0)
{ {
MmFreeSectionSegments(Bcb->FileObject); MmFreeSectionSegments(SharedCacheMap->FileObject);
CcRosDeleteFileCache(FileObject, Bcb); CcRosDeleteFileCache(FileObject, SharedCacheMap);
} }
} }
} }
@ -1157,14 +1159,14 @@ NTAPI
CcTryToInitializeFileCache ( CcTryToInitializeFileCache (
PFILE_OBJECT FileObject) PFILE_OBJECT FileObject)
{ {
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
NTSTATUS Status; NTSTATUS Status;
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
ASSERT(FileObject->SectionObjectPointer); ASSERT(FileObject->SectionObjectPointer);
Bcb = FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
if (Bcb == NULL) if (SharedCacheMap == NULL)
{ {
Status = STATUS_UNSUCCESSFUL; Status = STATUS_UNSUCCESSFUL;
} }
@ -1172,8 +1174,8 @@ CcTryToInitializeFileCache (
{ {
if (FileObject->PrivateCacheMap == NULL) if (FileObject->PrivateCacheMap == NULL)
{ {
FileObject->PrivateCacheMap = Bcb; FileObject->PrivateCacheMap = SharedCacheMap;
Bcb->RefCount++; SharedCacheMap->RefCount++;
} }
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
} }
@ -1190,47 +1192,47 @@ CcRosInitializeFileCache (
PCACHE_MANAGER_CALLBACKS CallBacks, PCACHE_MANAGER_CALLBACKS CallBacks,
PVOID LazyWriterContext) 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; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
DPRINT("CcRosInitializeFileCache(FileObject 0x%p, Bcb 0x%p)\n", DPRINT("CcRosInitializeFileCache(FileObject 0x%p, SharedCacheMap 0x%p)\n",
FileObject, Bcb); FileObject, SharedCacheMap);
KeAcquireGuardedMutex(&ViewLock); KeAcquireGuardedMutex(&ViewLock);
if (Bcb == NULL) if (SharedCacheMap == NULL)
{ {
Bcb = ExAllocateFromNPagedLookasideList(&BcbLookasideList); SharedCacheMap = ExAllocateFromNPagedLookasideList(&SharedCacheMapLookasideList);
if (Bcb == NULL) if (SharedCacheMap == NULL)
{ {
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
RtlZeroMemory(Bcb, sizeof(*Bcb)); RtlZeroMemory(SharedCacheMap, sizeof(*SharedCacheMap));
ObReferenceObjectByPointer(FileObject, ObReferenceObjectByPointer(FileObject,
FILE_ALL_ACCESS, FILE_ALL_ACCESS,
NULL, NULL,
KernelMode); KernelMode);
Bcb->FileObject = FileObject; SharedCacheMap->FileObject = FileObject;
Bcb->Callbacks = CallBacks; SharedCacheMap->Callbacks = CallBacks;
Bcb->LazyWriteContext = LazyWriterContext; SharedCacheMap->LazyWriteContext = LazyWriterContext;
if (FileObject->FsContext) if (FileObject->FsContext)
{ {
Bcb->AllocationSize = SharedCacheMap->AllocationSize =
((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->AllocationSize; ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->AllocationSize;
Bcb->FileSize = SharedCacheMap->FileSize =
((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->FileSize; ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->FileSize;
} }
KeInitializeSpinLock(&Bcb->BcbLock); KeInitializeSpinLock(&SharedCacheMap->CacheMapLock);
InitializeListHead(&Bcb->BcbVacbListHead); InitializeListHead(&SharedCacheMap->CacheMapVacbListHead);
FileObject->SectionObjectPointer->SharedCacheMap = Bcb; FileObject->SectionObjectPointer->SharedCacheMap = SharedCacheMap;
} }
if (FileObject->PrivateCacheMap == NULL) if (FileObject->PrivateCacheMap == NULL)
{ {
FileObject->PrivateCacheMap = Bcb; FileObject->PrivateCacheMap = SharedCacheMap;
Bcb->RefCount++; SharedCacheMap->RefCount++;
} }
KeReleaseGuardedMutex(&ViewLock); KeReleaseGuardedMutex(&ViewLock);
@ -1245,12 +1247,12 @@ NTAPI
CcGetFileObjectFromSectionPtrs ( CcGetFileObjectFromSectionPtrs (
IN PSECTION_OBJECT_POINTERS SectionObjectPointers) IN PSECTION_OBJECT_POINTERS SectionObjectPointers)
{ {
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap) if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
{ {
Bcb = (PBCB)SectionObjectPointers->SharedCacheMap; SharedCacheMap = SectionObjectPointers->SharedCacheMap;
ASSERT(Bcb); ASSERT(SharedCacheMap);
return Bcb->FileObject; return SharedCacheMap->FileObject;
} }
return NULL; return NULL;
} }
@ -1274,11 +1276,11 @@ CcInitView (
sizeof(INTERNAL_BCB), sizeof(INTERNAL_BCB),
TAG_IBCB, TAG_IBCB,
20); 20);
ExInitializeNPagedLookasideList (&BcbLookasideList, ExInitializeNPagedLookasideList (&SharedCacheMapLookasideList,
NULL, NULL,
NULL, NULL,
0, 0,
sizeof(BCB), sizeof(ROS_SHARED_CACHE_MAP),
TAG_BCB, TAG_BCB,
20); 20);
ExInitializeNPagedLookasideList (&VacbLookasideList, ExInitializeNPagedLookasideList (&VacbLookasideList,

32
reactos/ntoskrnl/include/internal/cc.h
View file

@ -101,21 +101,21 @@ typedef struct _PFSN_PREFETCHER_GLOBALS
LONG ActivePrefetches; LONG ActivePrefetches;
} PFSN_PREFETCHER_GLOBALS, *PPFSN_PREFETCHER_GLOBALS; } PFSN_PREFETCHER_GLOBALS, *PPFSN_PREFETCHER_GLOBALS;
typedef struct _BCB typedef struct _ROS_SHARED_CACHE_MAP
{ {
LIST_ENTRY BcbVacbListHead; LIST_ENTRY CacheMapVacbListHead;
ULONG TimeStamp; ULONG TimeStamp;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
LARGE_INTEGER AllocationSize; LARGE_INTEGER AllocationSize;
LARGE_INTEGER FileSize; LARGE_INTEGER FileSize;
PCACHE_MANAGER_CALLBACKS Callbacks; PCACHE_MANAGER_CALLBACKS Callbacks;
PVOID LazyWriteContext; PVOID LazyWriteContext;
KSPIN_LOCK BcbLock; KSPIN_LOCK CacheMapLock;
ULONG RefCount; ULONG RefCount;
#if DBG #if DBG
BOOLEAN Trace; /* enable extra trace output for this BCB and it's VACBs */ BOOLEAN Trace; /* enable extra trace output for this cache map and it's VACBs */
#endif #endif
} BCB, *PBCB; } ROS_SHARED_CACHE_MAP, *PROS_SHARED_CACHE_MAP;
typedef struct _ROS_VACB typedef struct _ROS_VACB
{ {
@ -130,8 +130,8 @@ typedef struct _ROS_VACB
/* Page out in progress */ /* Page out in progress */
BOOLEAN PageOut; BOOLEAN PageOut;
ULONG MappedCount; ULONG MappedCount;
/* Entry in the list of VACBs for this BCB. */ /* Entry in the list of VACBs for this shared cache map. */
LIST_ENTRY BcbVacbListEntry; LIST_ENTRY CacheMapVacbListEntry;
/* Entry in the list of VACBs which are dirty. */ /* Entry in the list of VACBs which are dirty. */
LIST_ENTRY DirtyVacbListEntry; LIST_ENTRY DirtyVacbListEntry;
/* Entry in the list of VACBs. */ /* Entry in the list of VACBs. */
@ -143,8 +143,8 @@ typedef struct _ROS_VACB
KMUTEX Mutex; KMUTEX Mutex;
/* Number of references. */ /* Number of references. */
ULONG ReferenceCount; ULONG ReferenceCount;
/* Pointer to the BCB for the file which this view maps data for. */ /* Pointer to the shared cache map for the file which this view maps data for. */
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
/* Pointer to the next VACB in a chain. */ /* Pointer to the next VACB in a chain. */
struct _ROS_VACB *NextInChain; struct _ROS_VACB *NextInChain;
} ROS_VACB, *PROS_VACB; } ROS_VACB, *PROS_VACB;
@ -185,7 +185,7 @@ CcRosFlushVacb(PROS_VACB Vacb);
NTSTATUS NTSTATUS
NTAPI NTAPI
CcRosGetVacb( CcRosGetVacb(
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
ULONG FileOffset, ULONG FileOffset,
PULONG BaseOffset, PULONG BaseOffset,
PVOID *BaseAddress, PVOID *BaseAddress,
@ -212,7 +212,7 @@ CcInitializeCacheManager(VOID);
NTSTATUS NTSTATUS
NTAPI NTAPI
CcRosUnmapVacb( CcRosUnmapVacb(
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
ULONG FileOffset, ULONG FileOffset,
BOOLEAN NowDirty BOOLEAN NowDirty
); );
@ -220,14 +220,14 @@ CcRosUnmapVacb(
PROS_VACB PROS_VACB
NTAPI NTAPI
CcRosLookupVacb( CcRosLookupVacb(
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
ULONG FileOffset ULONG FileOffset
); );
NTSTATUS NTSTATUS
NTAPI NTAPI
CcRosGetVacbChain( CcRosGetVacbChain(
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
ULONG FileOffset, ULONG FileOffset,
ULONG Length, ULONG Length,
PROS_VACB *Vacb PROS_VACB *Vacb
@ -240,7 +240,7 @@ CcInitCacheZeroPage(VOID);
NTSTATUS NTSTATUS
NTAPI NTAPI
CcRosMarkDirtyVacb( CcRosMarkDirtyVacb(
PBCB Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
ULONG FileOffset ULONG FileOffset
); );
@ -267,7 +267,7 @@ CcRosRemoveIfClosed(PSECTION_OBJECT_POINTERS SectionObjectPointer);
NTSTATUS NTSTATUS
NTAPI NTAPI
CcRosReleaseVacb( CcRosReleaseVacb(
BCB* Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
PROS_VACB Vacb, PROS_VACB Vacb,
BOOLEAN Valid, BOOLEAN Valid,
BOOLEAN Dirty, BOOLEAN Dirty,
@ -277,7 +277,7 @@ CcRosReleaseVacb(
NTSTATUS NTSTATUS
NTAPI NTAPI
CcRosRequestVacb( CcRosRequestVacb(
BCB *Bcb, PROS_SHARED_CACHE_MAP SharedCacheMap,
ULONG FileOffset, ULONG FileOffset,
PVOID* BaseAddress, PVOID* BaseAddress,
PBOOLEAN UptoDate, PBOOLEAN UptoDate,

62
reactos/ntoskrnl/mm/section.c
View file

@ -896,7 +896,7 @@ MmUnsharePageEntrySectionSegment(PROS_SECTION_OBJECT Section,
{ {
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
#ifndef NEWCC #ifndef NEWCC
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
#endif #endif
SWAPENTRY SavedSwapEntry; SWAPENTRY SavedSwapEntry;
PFN_NUMBER Page; PFN_NUMBER Page;
@ -918,10 +918,10 @@ MmUnsharePageEntrySectionSegment(PROS_SECTION_OBJECT Section,
(Offset->QuadPart + PAGE_SIZE <= Segment->RawLength.QuadPart || !IsImageSection)) (Offset->QuadPart + PAGE_SIZE <= Segment->RawLength.QuadPart || !IsImageSection))
{ {
NTSTATUS Status; NTSTATUS Status;
Bcb = FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
IsDirectMapped = TRUE; IsDirectMapped = TRUE;
#ifndef NEWCC #ifndef NEWCC
Status = CcRosUnmapVacb(Bcb, FileOffset.LowPart, Dirty); Status = CcRosUnmapVacb(SharedCacheMap, FileOffset.LowPart, Dirty);
#else #else
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
#endif #endif
@ -1015,13 +1015,13 @@ BOOLEAN MiIsPageFromCache(PMEMORY_AREA MemoryArea,
#ifndef NEWCC #ifndef NEWCC
if (!(MemoryArea->Data.SectionData.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED)) if (!(MemoryArea->Data.SectionData.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
{ {
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
PROS_VACB Vacb; PROS_VACB Vacb;
Bcb = MemoryArea->Data.SectionData.Section->FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = MemoryArea->Data.SectionData.Section->FileObject->SectionObjectPointer->SharedCacheMap;
Vacb = CcRosLookupVacb(Bcb, (ULONG)(SegOffset + MemoryArea->Data.SectionData.Segment->Image.FileOffset)); Vacb = CcRosLookupVacb(SharedCacheMap, (ULONG)(SegOffset + MemoryArea->Data.SectionData.Segment->Image.FileOffset));
if (Vacb) if (Vacb)
{ {
CcRosReleaseVacb(Bcb, Vacb, Vacb->Valid, FALSE, TRUE); CcRosReleaseVacb(SharedCacheMap, Vacb, Vacb->Valid, FALSE, TRUE);
return TRUE; return TRUE;
} }
} }
@ -1074,17 +1074,17 @@ MiReadPage(PMEMORY_AREA MemoryArea,
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
NTSTATUS Status; NTSTATUS Status;
ULONG_PTR RawLength; ULONG_PTR RawLength;
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
BOOLEAN IsImageSection; BOOLEAN IsImageSection;
ULONG_PTR Length; ULONG_PTR Length;
FileObject = MemoryArea->Data.SectionData.Section->FileObject; FileObject = MemoryArea->Data.SectionData.Section->FileObject;
Bcb = FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
RawLength = (ULONG_PTR)(MemoryArea->Data.SectionData.Segment->RawLength.QuadPart); RawLength = (ULONG_PTR)(MemoryArea->Data.SectionData.Segment->RawLength.QuadPart);
FileOffset = SegOffset + MemoryArea->Data.SectionData.Segment->Image.FileOffset; FileOffset = SegOffset + MemoryArea->Data.SectionData.Segment->Image.FileOffset;
IsImageSection = MemoryArea->Data.SectionData.Section->AllocationAttributes & SEC_IMAGE ? TRUE : FALSE; IsImageSection = MemoryArea->Data.SectionData.Section->AllocationAttributes & SEC_IMAGE ? TRUE : FALSE;
ASSERT(Bcb); ASSERT(SharedCacheMap);
DPRINT("%S %I64x\n", FileObject->FileName.Buffer, FileOffset); DPRINT("%S %I64x\n", FileObject->FileName.Buffer, FileOffset);
@ -1103,7 +1103,7 @@ MiReadPage(PMEMORY_AREA MemoryArea,
* filesystems do because it is safe for us to use an offset with an * filesystems do because it is safe for us to use an offset with an
* alignment less than the file system block size. * alignment less than the file system block size.
*/ */
Status = CcRosGetVacb(Bcb, Status = CcRosGetVacb(SharedCacheMap,
(ULONG)FileOffset, (ULONG)FileOffset,
&BaseOffset, &BaseOffset,
&BaseAddress, &BaseAddress,
@ -1122,7 +1122,7 @@ MiReadPage(PMEMORY_AREA MemoryArea,
Status = CcReadVirtualAddress(Vacb); Status = CcReadVirtualAddress(Vacb);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
CcRosReleaseVacb(Bcb, Vacb, FALSE, FALSE, FALSE); CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
return Status; return Status;
} }
} }
@ -1136,7 +1136,7 @@ MiReadPage(PMEMORY_AREA MemoryArea,
(*Page) = MmGetPhysicalAddress((char*)BaseAddress + (*Page) = MmGetPhysicalAddress((char*)BaseAddress +
FileOffset - BaseOffset).LowPart >> PAGE_SHIFT; FileOffset - BaseOffset).LowPart >> PAGE_SHIFT;
CcRosReleaseVacb(Bcb, Vacb, TRUE, FALSE, TRUE); CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, TRUE);
} }
else else
{ {
@ -1156,7 +1156,7 @@ MiReadPage(PMEMORY_AREA MemoryArea,
{ {
return(Status); return(Status);
} }
Status = CcRosGetVacb(Bcb, Status = CcRosGetVacb(SharedCacheMap,
(ULONG)FileOffset, (ULONG)FileOffset,
&BaseOffset, &BaseOffset,
&BaseAddress, &BaseAddress,
@ -1175,7 +1175,7 @@ MiReadPage(PMEMORY_AREA MemoryArea,
Status = CcReadVirtualAddress(Vacb); Status = CcReadVirtualAddress(Vacb);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
CcRosReleaseVacb(Bcb, Vacb, FALSE, FALSE, FALSE); CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
return Status; return Status;
} }
} }
@ -1196,8 +1196,8 @@ MiReadPage(PMEMORY_AREA MemoryArea,
{ {
memcpy(PageAddr, (char*)BaseAddress + FileOffset - BaseOffset, VacbOffset); memcpy(PageAddr, (char*)BaseAddress + FileOffset - BaseOffset, VacbOffset);
MiUnmapPageInHyperSpace(Process, PageAddr, Irql); MiUnmapPageInHyperSpace(Process, PageAddr, Irql);
CcRosReleaseVacb(Bcb, Vacb, TRUE, FALSE, FALSE); CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
Status = CcRosGetVacb(Bcb, Status = CcRosGetVacb(SharedCacheMap,
(ULONG)(FileOffset + VacbOffset), (ULONG)(FileOffset + VacbOffset),
&BaseOffset, &BaseOffset,
&BaseAddress, &BaseAddress,
@ -1216,7 +1216,7 @@ MiReadPage(PMEMORY_AREA MemoryArea,
Status = CcReadVirtualAddress(Vacb); Status = CcReadVirtualAddress(Vacb);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
CcRosReleaseVacb(Bcb, Vacb, FALSE, FALSE, FALSE); CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
return Status; return Status;
} }
} }
@ -1231,7 +1231,7 @@ MiReadPage(PMEMORY_AREA MemoryArea,
} }
} }
MiUnmapPageInHyperSpace(Process, PageAddr, Irql); MiUnmapPageInHyperSpace(Process, PageAddr, Irql);
CcRosReleaseVacb(Bcb, Vacb, TRUE, FALSE, FALSE); CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
} }
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
@ -1869,7 +1869,7 @@ MmPageOutSectionView(PMMSUPPORT AddressSpace,
NTSTATUS Status; NTSTATUS Status;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
#ifndef NEWCC #ifndef NEWCC
PBCB Bcb = NULL; PROS_SHARED_CACHE_MAP SharedCacheMap = NULL;
#endif #endif
BOOLEAN DirectMapped; BOOLEAN DirectMapped;
BOOLEAN IsImageSection; BOOLEAN IsImageSection;
@ -1901,7 +1901,7 @@ MmPageOutSectionView(PMMSUPPORT AddressSpace,
if (FileObject != NULL && if (FileObject != NULL &&
!(Context.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED)) !(Context.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
{ {
Bcb = FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
/* /*
* If the file system is letting us go directly to the cache and the * If the file system is letting us go directly to the cache and the
@ -2066,7 +2066,7 @@ MmPageOutSectionView(PMMSUPPORT AddressSpace,
KeBugCheckEx(MEMORY_MANAGEMENT, STATUS_UNSUCCESSFUL, SwapEntry, (ULONG_PTR)Process, (ULONG_PTR)Address); KeBugCheckEx(MEMORY_MANAGEMENT, STATUS_UNSUCCESSFUL, SwapEntry, (ULONG_PTR)Process, (ULONG_PTR)Address);
} }
#ifndef NEWCC #ifndef NEWCC
Status = CcRosUnmapVacb(Bcb, (ULONG)FileOffset, FALSE); Status = CcRosUnmapVacb(SharedCacheMap, (ULONG)FileOffset, FALSE);
#else #else
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
#endif #endif
@ -2074,7 +2074,7 @@ MmPageOutSectionView(PMMSUPPORT AddressSpace,
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
DPRINT1("CcRosUnmapVacb failed, status = %x\n", Status); DPRINT1("CcRosUnmapVacb failed, status = %x\n", Status);
KeBugCheckEx(MEMORY_MANAGEMENT, Status, (ULONG_PTR)Bcb, (ULONG_PTR)FileOffset, (ULONG_PTR)Address); KeBugCheckEx(MEMORY_MANAGEMENT, Status, (ULONG_PTR)SharedCacheMap, (ULONG_PTR)FileOffset, (ULONG_PTR)Address);
} }
#endif #endif
MiSetPageEvent(NULL, NULL); MiSetPageEvent(NULL, NULL);
@ -2276,7 +2276,7 @@ MmWritePageSectionView(PMMSUPPORT AddressSpace,
BOOLEAN Private; BOOLEAN Private;
NTSTATUS Status; NTSTATUS Status;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PBCB Bcb = NULL; PROS_SHARED_CACHE_MAP SharedCacheMap = NULL;
BOOLEAN DirectMapped; BOOLEAN DirectMapped;
BOOLEAN IsImageSection; BOOLEAN IsImageSection;
PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace); PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace);
@ -2298,7 +2298,7 @@ MmWritePageSectionView(PMMSUPPORT AddressSpace,
if (FileObject != NULL && if (FileObject != NULL &&
!(Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED)) !(Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
{ {
Bcb = FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
/* /*
* If the file system is letting us go directly to the cache and the * If the file system is letting us go directly to the cache and the
@ -2366,7 +2366,7 @@ MmWritePageSectionView(PMMSUPPORT AddressSpace,
ASSERT(SwapEntry == 0); ASSERT(SwapEntry == 0);
//SOffset.QuadPart = Offset.QuadPart + Segment->Image.FileOffset; //SOffset.QuadPart = Offset.QuadPart + Segment->Image.FileOffset;
#ifndef NEWCC #ifndef NEWCC
CcRosMarkDirtyVacb(Bcb, Offset.LowPart); CcRosMarkDirtyVacb(SharedCacheMap, Offset.LowPart);
#endif #endif
MmLockSectionSegment(Segment); MmLockSectionSegment(Segment);
MmSetPageEntrySectionSegment(Segment, &Offset, PageEntry); MmSetPageEntrySectionSegment(Segment, &Offset, PageEntry);
@ -3970,7 +3970,7 @@ MmFreeSectionPage(PVOID Context, MEMORY_AREA* MemoryArea, PVOID Address,
{ {
ULONG_PTR Entry; ULONG_PTR Entry;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PBCB Bcb; PROS_SHARED_CACHE_MAP SharedCacheMap;
LARGE_INTEGER Offset; LARGE_INTEGER Offset;
SWAPENTRY SavedSwapEntry; SWAPENTRY SavedSwapEntry;
PROS_SECTION_OBJECT Section; PROS_SECTION_OBJECT Section;
@ -4011,9 +4011,9 @@ MmFreeSectionPage(PVOID Context, MEMORY_AREA* MemoryArea, PVOID Address,
if (Page == PFN_FROM_SSE(Entry) && Dirty) if (Page == PFN_FROM_SSE(Entry) && Dirty)
{ {
FileObject = MemoryArea->Data.SectionData.Section->FileObject; FileObject = MemoryArea->Data.SectionData.Section->FileObject;
Bcb = FileObject->SectionObjectPointer->SharedCacheMap; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
#ifndef NEWCC #ifndef NEWCC
CcRosMarkDirtyVacb(Bcb, (ULONG)(Offset.QuadPart + Segment->Image.FileOffset)); CcRosMarkDirtyVacb(SharedCacheMap, (ULONG)(Offset.QuadPart + Segment->Image.FileOffset));
#endif #endif
ASSERT(SwapEntry == 0); ASSERT(SwapEntry == 0);
} }
@ -4674,8 +4674,8 @@ MmCanFileBeTruncated (IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
/* Check size of file */ /* Check size of file */
if (SectionObjectPointer->SharedCacheMap) if (SectionObjectPointer->SharedCacheMap)
{ {
PBCB Bcb = SectionObjectPointer->SharedCacheMap; PROS_SHARED_CACHE_MAP SharedCacheMap = SectionObjectPointer->SharedCacheMap;
if (NewFileSize->QuadPart <= Bcb->FileSize.QuadPart) if (NewFileSize->QuadPart <= SharedCacheMap->FileSize.QuadPart)
{ {
return FALSE; return FALSE;
} }