[NTOS:CC]

- 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

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

diff --git a/reactos/ntoskrnl/cc/fs.c b/reactos/ntoskrnl/cc/fs.c
index 1ee69d5..d806d38 100644 (file)
--- a/reactos/ntoskrnl/cc/fs.c
+++ b/reactos/ntoskrnl/cc/fs.c
@@ -52,7 +52,7 @@ CcGetFileObjectFromBcb (
     IN PVOID 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)
 {
     KIRQL oldirql;
-    PBCB Bcb;
+    PROS_SHARED_CACHE_MAP SharedCacheMap;
     PLIST_ENTRY current_entry;
     PROS_VACB current;
     LIST_ENTRY FreeListHead;
@@ -141,33 +141,33 @@ CcSetFileSizes (
            FileSizes->FileSize.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
      * initialized for caching. In this case it's simple no-op.
      */
-    if (Bcb == NULL)
+    if (SharedCacheMap == NULL)
         return;
 
-    if (FileSizes->AllocationSize.QuadPart < Bcb->AllocationSize.QuadPart)
+    if (FileSizes->AllocationSize.QuadPart < SharedCacheMap->AllocationSize.QuadPart)
     {
         InitializeListHead(&FreeListHead);
         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);
+                                        CacheMapVacbListEntry);
             current_entry = current_entry->Flink;
             if (current->FileOffset >= FileSizes->AllocationSize.QuadPart)
             {
                 if ((current->ReferenceCount == 0) || ((current->ReferenceCount == 1) && current->Dirty))
                 {
-                    RemoveEntryList(&current->BcbVacbListEntry);
+                    RemoveEntryList(&current->CacheMapVacbListEntry);
                     RemoveEntryList(&current->VacbListEntry);
                     RemoveEntryList(&current->VacbLruListEntry);
                     if (current->Dirty)
@@ -175,7 +175,7 @@ CcSetFileSizes (
                         RemoveEntryList(&current->DirtyVacbListEntry);
                         DirtyPageCount -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
                     }
-                    InsertHeadList(&FreeListHead, &current->BcbVacbListEntry);
+                    InsertHeadList(&FreeListHead, &current->CacheMapVacbListEntry);
                 }
                 else
                 {
@@ -185,15 +185,15 @@ CcSetFileSizes (
             }
         }
 
-        Bcb->AllocationSize = FileSizes->AllocationSize;
-        Bcb->FileSize = FileSizes->FileSize;
-        KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
+        SharedCacheMap->AllocationSize = FileSizes->AllocationSize;
+        SharedCacheMap->FileSize = FileSizes->FileSize;
+        KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
         KeReleaseGuardedMutex(&ViewLock);
 
         current_entry = FreeListHead.Flink;
         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;
             Status = CcRosInternalFreeVacb(current);
             if (!NT_SUCCESS(Status))
@@ -205,10 +205,10 @@ CcSetFileSizes (
     }
     else
     {
-        KeAcquireSpinLock(&Bcb->BcbLock, &oldirql);
-        Bcb->AllocationSize = FileSizes->AllocationSize;
-        Bcb->FileSize = FileSizes->FileSize;
-        KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
+        KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldirql);
+        SharedCacheMap->AllocationSize = FileSizes->AllocationSize;
+        SharedCacheMap->FileSize = FileSizes->FileSize;
+        KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
     }
 }
 
@@ -249,14 +249,14 @@ CcGetFileSizes (
     IN PFILE_OBJECT FileObject,
     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;
 
-    FileSizes->AllocationSize = Bcb->AllocationSize;
-    FileSizes->FileSize = FileSizes->ValidDataLength = Bcb->FileSize;
+    FileSizes->AllocationSize = SharedCacheMap->AllocationSize;
+    FileSizes->FileSize = FileSizes->ValidDataLength = SharedCacheMap->FileSize;
     return TRUE;
 }

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

diff --git a/reactos/ntoskrnl/cc/view.c b/reactos/ntoskrnl/cc/view.c
index 146659d..e151c7a 100644 (file)
--- a/reactos/ntoskrnl/cc/view.c
+++ b/reactos/ntoskrnl/cc/view.c
@@ -49,14 +49,14 @@ 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);
@@ -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)
 {
     --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);
@@ -87,7 +87,7 @@ CcRosInternalFreeVacb(PROS_VACB Vacb);
 VOID
 NTAPI
 CcRosTraceCacheMap (
-    PBCB Bcb,
+    PROS_SHARED_CACHE_MAP SharedCacheMap,
     BOOLEAN Trace )
 {
 #if DBG
@@ -95,38 +95,38 @@ CcRosTraceCacheMap (
     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
 }
 
@@ -142,14 +142,14 @@ CcRosFlushVacb (
     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);
     }
 
@@ -192,8 +192,8 @@ CcRosFlushDirtyPages (
 
         CcRosVacbIncRefCount(current);
 
-        Locked = current->Bcb->Callbacks->AcquireForLazyWrite(
-                     current->Bcb->LazyWriteContext, Wait);
+        Locked = current->SharedCacheMap->Callbacks->AcquireForLazyWrite(
+                     current->SharedCacheMap->LazyWriteContext, Wait);
         if (!Locked)
         {
             CcRosVacbDecRefCount(current);
@@ -207,8 +207,8 @@ CcRosFlushDirtyPages (
                                        Wait ? NULL : &ZeroTimeout);
         if (Status != STATUS_SUCCESS)
         {
-            current->Bcb->Callbacks->ReleaseFromLazyWrite(
-                current->Bcb->LazyWriteContext);
+            current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
+                current->SharedCacheMap->LazyWriteContext);
             CcRosVacbDecRefCount(current);
             continue;
         }
@@ -219,8 +219,8 @@ CcRosFlushDirtyPages (
         if (current->ReferenceCount > 2)
         {
             KeReleaseMutex(&current->Mutex, FALSE);
-            current->Bcb->Callbacks->ReleaseFromLazyWrite(
-                current->Bcb->LazyWriteContext);
+            current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
+                current->SharedCacheMap->LazyWriteContext);
             CcRosVacbDecRefCount(current);
             continue;
         }
@@ -230,8 +230,8 @@ CcRosFlushDirtyPages (
         Status = CcRosFlushVacb(current);
 
         KeReleaseMutex(&current->Mutex, FALSE);
-        current->Bcb->Callbacks->ReleaseFromLazyWrite(
-            current->Bcb->LazyWriteContext);
+        current->SharedCacheMap->Callbacks->ReleaseFromLazyWrite(
+            current->SharedCacheMap->LazyWriteContext);
 
         KeAcquireGuardedMutex(&ViewLock);
         CcRosVacbDecRefCount(current);
@@ -296,7 +296,7 @@ retry:
                                     VacbLruListEntry);
         current_entry = current_entry->Flink;
 
-        KeAcquireSpinLock(&current->Bcb->BcbLock, &oldIrql);
+        KeAcquireSpinLock(&current->SharedCacheMap->CacheMapLock, &oldIrql);
 
         /* Reference the VACB */
         CcRosVacbIncRefCount(current);
@@ -305,7 +305,7 @@ retry:
         if (current->MappedCount > 0 && !current->Dirty)
         {
             /* We have to break these locks because Cc sucks */
-            KeReleaseSpinLock(&current->Bcb->BcbLock, oldIrql);
+            KeReleaseSpinLock(&current->SharedCacheMap->CacheMapLock, oldIrql);
             KeReleaseGuardedMutex(&ViewLock);
 
             /* Page out the VACB */
@@ -318,7 +318,7 @@ retry:
 
             /* Reacquire the locks */
             KeAcquireGuardedMutex(&ViewLock);
-            KeAcquireSpinLock(&current->Bcb->BcbLock, &oldIrql);
+            KeAcquireSpinLock(&current->SharedCacheMap->CacheMapLock, &oldIrql);
         }
 
         /* Dereference the VACB */
@@ -330,10 +330,10 @@ retry:
             ASSERT(!current->Dirty);
             ASSERT(!current->MappedCount);
 
-            RemoveEntryList(&current->BcbVacbListEntry);
+            RemoveEntryList(&current->CacheMapVacbListEntry);
             RemoveEntryList(&current->VacbListEntry);
             RemoveEntryList(&current->VacbLruListEntry);
-            InsertHeadList(&FreeList, &current->BcbVacbListEntry);
+            InsertHeadList(&FreeList, &current->CacheMapVacbListEntry);
 
             /* Calculate how many pages we freed for Mm */
             PagesFreed = min(VACB_MAPPING_GRANULARITY / PAGE_SIZE, Target);
@@ -341,7 +341,7 @@ retry:
             (*NrFreed) += PagesFreed;
         }
 
-        KeReleaseSpinLock(&current->Bcb->BcbLock, oldIrql);
+        KeReleaseSpinLock(&current->SharedCacheMap->CacheMapLock, oldIrql);
     }
 
     KeReleaseGuardedMutex(&ViewLock);
@@ -370,7 +370,7 @@ retry:
         current_entry = RemoveHeadList(&FreeList);
         current = CONTAINING_RECORD(current_entry,
                                     ROS_VACB,
-                                    BcbVacbListEntry);
+                                    CacheMapVacbListEntry);
         CcRosInternalFreeVacb(current);
     }
 
@@ -382,7 +382,7 @@ retry:
 NTSTATUS
 NTAPI
 CcRosReleaseVacb (
-    PBCB Bcb,
+    PROS_SHARED_CACHE_MAP SharedCacheMap,
     PROS_VACB Vacb,
     BOOLEAN Valid,
     BOOLEAN Dirty,
@@ -391,13 +391,13 @@ CcRosReleaseVacb (
     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;
 
@@ -424,7 +424,7 @@ CcRosReleaseVacb (
         CcRosVacbIncRefCount(Vacb);
     }
 
-    KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+    KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
     KeReleaseGuardedMutex(&ViewLock);
     KeReleaseMutex(&Vacb->Mutex, FALSE);
 
@@ -435,31 +435,32 @@ CcRosReleaseVacb (
 PROS_VACB
 NTAPI
 CcRosLookupVacb (
-    PBCB Bcb,
+    PROS_SHARED_CACHE_MAP SharedCacheMap,
     ULONG 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 %lu)\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);
+                                    CacheMapVacbListEntry);
         if (IsPointInRange(current->FileOffset, VACB_MAPPING_GRANULARITY,
                            FileOffset))
         {
             CcRosVacbIncRefCount(current);
-            KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+            KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
             KeReleaseGuardedMutex(&ViewLock);
             KeWaitForSingleObject(&current->Mutex,
                                   Executive,
@@ -473,7 +474,7 @@ CcRosLookupVacb (
         current_entry = current_entry->Flink;
     }
 
-    KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+    KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
     KeReleaseGuardedMutex(&ViewLock);
 
     return NULL;
@@ -482,24 +483,25 @@ CcRosLookupVacb (
 NTSTATUS
 NTAPI
 CcRosMarkDirtyVacb (
-    PBCB Bcb,
+    PROS_SHARED_CACHE_MAP SharedCacheMap,
     ULONG 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 %lu)\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)
     {
@@ -517,7 +519,7 @@ CcRosMarkDirtyVacb (
 
     Vacb->Dirty = TRUE;
 
-    KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+    KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
     KeReleaseGuardedMutex(&ViewLock);
     KeReleaseMutex(&Vacb->Mutex, FALSE);
 
@@ -527,7 +529,7 @@ CcRosMarkDirtyVacb (
 NTSTATUS
 NTAPI
 CcRosUnmapVacb (
-    PBCB Bcb,
+    PROS_SHARED_CACHE_MAP SharedCacheMap,
     ULONG FileOffset,
     BOOLEAN NowDirty)
 {
@@ -535,19 +537,19 @@ CcRosUnmapVacb (
     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 %lu, 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;
@@ -570,7 +572,7 @@ CcRosUnmapVacb (
         CcRosVacbDecRefCount(Vacb);
     }
 
-    KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+    KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
     KeReleaseGuardedMutex(&ViewLock);
     KeReleaseMutex(&Vacb->Mutex, FALSE);
 
@@ -580,7 +582,7 @@ CcRosUnmapVacb (
 static
 NTSTATUS
 CcRosCreateVacb (
-    PBCB Bcb,
+    PROS_SHARED_CACHE_MAP SharedCacheMap,
     ULONG FileOffset,
     PROS_VACB *Vacb)
 {
@@ -590,11 +592,11 @@ CcRosCreateVacb (
     NTSTATUS Status;
     KIRQL oldIrql;
 
-    ASSERT(Bcb);
+    ASSERT(SharedCacheMap);
 
     DPRINT("CcRosCreateVacb()\n");
 
-    if (FileOffset >= Bcb->FileSize.u.LowPart)
+    if (FileOffset >= SharedCacheMap->FileSize.u.LowPart)
     {
         *Vacb = NULL;
         return STATUS_INVALID_PARAMETER;
@@ -605,11 +607,11 @@ CcRosCreateVacb (
     current->Dirty = FALSE;
     current->PageOut = FALSE;
     current->FileOffset = ROUND_DOWN(FileOffset, VACB_MAPPING_GRANULARITY);
-    current->Bcb = Bcb;
+    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;
@@ -630,26 +632,26 @@ CcRosCreateVacb (
      * 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);
+                                    CacheMapVacbListEntry);
         if (IsPointInRange(current->FileOffset, 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);
@@ -677,13 +679,13 @@ CcRosCreateVacb (
     current = *Vacb;
     if (previous)
     {
-        InsertHeadList(&previous->BcbVacbListEntry, &current->BcbVacbListEntry);
+        InsertHeadList(&previous->CacheMapVacbListEntry, &current->CacheMapVacbListEntry);
     }
     else
     {
-        InsertHeadList(&Bcb->BcbVacbListHead, &current->BcbVacbListEntry);
+        InsertHeadList(&SharedCacheMap->CacheMapVacbListHead, &current->CacheMapVacbListEntry);
     }
-    KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+    KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
     InsertTailList(&VacbListHead, &current->VacbListEntry);
     InsertTailList(&VacbLruListHead, &current->VacbLruListEntry);
     KeReleaseGuardedMutex(&ViewLock);
@@ -710,9 +712,9 @@ CcRosCreateVacb (
 #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, '\\');
+        pos = wcsrchr(SharedCacheMap->FileObject->FileName.Buffer, '\\');
         len = wcslen(pos) * sizeof(WCHAR);
         if (pos) snprintf(MI_PFN_CURRENT_PROCESS_NAME, min(16, len), "%S", pos);
     }
@@ -727,7 +729,7 @@ CcRosCreateVacb (
 NTSTATUS
 NTAPI
 CcRosGetVacbChain (
-    PBCB Bcb,
+    PROS_SHARED_CACHE_MAP SharedCacheMap,
     ULONG FileOffset,
     ULONG Length,
     PROS_VACB *Vacb)
@@ -737,7 +739,7 @@ CcRosGetVacbChain (
     PROS_VACB *VacbList;
     PROS_VACB Previous = NULL;
 
-    ASSERT(Bcb);
+    ASSERT(SharedCacheMap);
 
     DPRINT("CcRosGetVacbChain()\n");
 
@@ -752,7 +754,7 @@ CcRosGetVacbChain (
     for (i = 0; i < (Length / VACB_MAPPING_GRANULARITY); i++)
     {
         ULONG CurrentOffset = FileOffset + (i * VACB_MAPPING_GRANULARITY);
-        current = CcRosLookupVacb(Bcb, CurrentOffset);
+        current = CcRosLookupVacb(SharedCacheMap, CurrentOffset);
         if (current != NULL)
         {
             KeAcquireGuardedMutex(&ViewLock);
@@ -767,7 +769,7 @@ CcRosGetVacbChain (
         }
         else
         {
-            CcRosCreateVacb(Bcb, CurrentOffset, &current);
+            CcRosCreateVacb(SharedCacheMap, CurrentOffset, &current);
             VacbList[i] = current;
         }
     }
@@ -794,7 +796,7 @@ CcRosGetVacbChain (
 NTSTATUS
 NTAPI
 CcRosGetVacb (
-    PBCB Bcb,
+    PROS_SHARED_CACHE_MAP SharedCacheMap,
     ULONG FileOffset,
     PULONG BaseOffset,
     PVOID* BaseAddress,
@@ -804,20 +806,20 @@ CcRosGetVacb (
     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, &current);
+        Status = CcRosCreateVacb(SharedCacheMap, FileOffset, &current);
         if (!NT_SUCCESS(Status))
         {
             return Status;
@@ -846,18 +848,18 @@ CcRosGetVacb (
 NTSTATUS
 NTAPI
 CcRosRequestVacb (
-    PBCB Bcb,
+    PROS_SHARED_CACHE_MAP SharedCacheMap,
     ULONG 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;
 
-    ASSERT(Bcb);
+    ASSERT(SharedCacheMap);
 
     if (FileOffset % VACB_MAPPING_GRANULARITY != 0)
     {
@@ -866,7 +868,7 @@ CcRosRequestVacb (
         KeBugCheck(CACHE_MANAGER);
     }
 
-    return CcRosGetVacb(Bcb,
+    return CcRosGetVacb(SharedCacheMap,
                         FileOffset,
                         &BaseOffset,
                         BaseAddress,
@@ -896,14 +898,14 @@ NTSTATUS
 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
 
@@ -929,7 +931,7 @@ CcFlushCache (
     IN ULONG Length,
     OUT PIO_STATUS_BLOCK IoStatus)
 {
-    PBCB Bcb;
+    PROS_SHARED_CACHE_MAP SharedCacheMap;
     LARGE_INTEGER Offset;
     PROS_VACB current;
     NTSTATUS Status;
@@ -940,8 +942,8 @@ CcFlushCache (
 
     if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
     {
-        Bcb = (PBCB)SectionObjectPointers->SharedCacheMap;
-        ASSERT(Bcb);
+        SharedCacheMap = SectionObjectPointers->SharedCacheMap;
+        ASSERT(SharedCacheMap);
         if (FileOffset)
         {
             Offset = *FileOffset;
@@ -949,7 +951,7 @@ CcFlushCache (
         else
         {
             Offset.QuadPart = (LONGLONG)0;
-            Length = Bcb->FileSize.u.LowPart;
+            Length = SharedCacheMap->FileSize.u.LowPart;
         }
 
         if (IoStatus)
@@ -960,7 +962,7 @@ CcFlushCache (
 
         while (Length > 0)
         {
-            current = CcRosLookupVacb(Bcb, Offset.u.LowPart);
+            current = CcRosLookupVacb(SharedCacheMap, Offset.u.LowPart);
             if (current != NULL)
             {
                 if (current->Dirty)
@@ -974,9 +976,9 @@ CcFlushCache (
                 KeReleaseMutex(&current->Mutex, FALSE);
 
                 KeAcquireGuardedMutex(&ViewLock);
-                KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
+                KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldIrql);
                 CcRosVacbDecRefCount(current);
-                KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+                KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldIrql);
                 KeReleaseGuardedMutex(&ViewLock);
             }
 
@@ -1004,9 +1006,9 @@ NTSTATUS
 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;
@@ -1014,16 +1016,16 @@ CcRosDeleteFileCache (
     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)
     {
         FileObject->SectionObjectPointer->SharedCacheMap = NULL;
 
@@ -1031,11 +1033,11 @@ CcRosDeleteFileCache (
          * 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);
+            current_entry = RemoveTailList(&SharedCacheMap->CacheMapVacbListHead);
+            current = CONTAINING_RECORD(current_entry, ROS_VACB, CacheMapVacbListEntry);
             RemoveEntryList(&current->VacbListEntry);
             RemoveEntryList(&current->VacbLruListEntry);
             if (current->Dirty)
@@ -1044,23 +1046,23 @@ CcRosDeleteFileCache (
                 DirtyPageCount -= VACB_MAPPING_GRANULARITY / PAGE_SIZE;
                 DPRINT1("Freeing dirty VACB\n");
             }
-            InsertHeadList(&FreeList, &current->BcbVacbListEntry);
+            InsertHeadList(&FreeList, &current->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;
@@ -1071,12 +1073,12 @@ NTAPI
 CcRosReferenceCache (
     PFILE_OBJECT FileObject)
 {
-    PBCB Bcb;
+    PROS_SHARED_CACHE_MAP SharedCacheMap;
     KeAcquireGuardedMutex(&ViewLock);
-    Bcb = (PBCB)FileObject->SectionObjectPointer->SharedCacheMap;
-    ASSERT(Bcb);
-    ASSERT(Bcb->RefCount != 0);
-    Bcb->RefCount++;
+    SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
+    ASSERT(SharedCacheMap);
+    ASSERT(SharedCacheMap->RefCount != 0);
+    SharedCacheMap->RefCount++;
     KeReleaseGuardedMutex(&ViewLock);
 }
 
@@ -1085,13 +1087,13 @@ NTAPI
 CcRosRemoveIfClosed (
     PSECTION_OBJECT_POINTERS SectionObjectPointer)
 {
-    PBCB Bcb;
+    PROS_SHARED_CACHE_MAP SharedCacheMap;
     DPRINT("CcRosRemoveIfClosed()\n");
     KeAcquireGuardedMutex(&ViewLock);
-    Bcb = (PBCB)SectionObjectPointer->SharedCacheMap;
-    if (Bcb && Bcb->RefCount == 0)
+    SharedCacheMap = SectionObjectPointer->SharedCacheMap;
+    if (SharedCacheMap && SharedCacheMap->RefCount == 0)
     {
-        CcRosDeleteFileCache(Bcb->FileObject, Bcb);
+        CcRosDeleteFileCache(SharedCacheMap->FileObject, SharedCacheMap);
     }
     KeReleaseGuardedMutex(&ViewLock);
 }
@@ -1102,17 +1104,17 @@ NTAPI
 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);
@@ -1127,23 +1129,23 @@ CcRosReleaseFileCache (
  * 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);
                 }
             }
         }
@@ -1157,14 +1159,14 @@ NTAPI
 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;
     }
@@ -1172,8 +1174,8 @@ CcTryToInitializeFileCache (
     {
         if (FileObject->PrivateCacheMap == NULL)
         {
-            FileObject->PrivateCacheMap = Bcb;
-            Bcb->RefCount++;
+            FileObject->PrivateCacheMap = SharedCacheMap;
+            SharedCacheMap->RefCount++;
         }
         Status = STATUS_SUCCESS;
     }
@@ -1190,47 +1192,47 @@ CcRosInitializeFileCache (
     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;
+        SharedCacheMap->FileObject = FileObject;
+        SharedCacheMap->Callbacks = CallBacks;
+        SharedCacheMap->LazyWriteContext = LazyWriterContext;
         if (FileObject->FsContext)
         {
-            Bcb->AllocationSize =
+            SharedCacheMap->AllocationSize =
                 ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->AllocationSize;
-            Bcb->FileSize =
+            SharedCacheMap->FileSize =
                 ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->FileSize;
         }
-        KeInitializeSpinLock(&Bcb->BcbLock);
-        InitializeListHead(&Bcb->BcbVacbListHead);
-        FileObject->SectionObjectPointer->SharedCacheMap = Bcb;
+        KeInitializeSpinLock(&SharedCacheMap->CacheMapLock);
+        InitializeListHead(&SharedCacheMap->CacheMapVacbListHead);
+        FileObject->SectionObjectPointer->SharedCacheMap = SharedCacheMap;
     }
     if (FileObject->PrivateCacheMap == NULL)
     {
-        FileObject->PrivateCacheMap = Bcb;
-        Bcb->RefCount++;
+        FileObject->PrivateCacheMap = SharedCacheMap;
+        SharedCacheMap->RefCount++;
     }
     KeReleaseGuardedMutex(&ViewLock);
 
@@ -1245,12 +1247,12 @@ NTAPI
 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;
 }
@@ -1274,11 +1276,11 @@ CcInitView (
                                      sizeof(INTERNAL_BCB),
                                      TAG_IBCB,
                                      20);
-    ExInitializeNPagedLookasideList (&BcbLookasideList,
+    ExInitializeNPagedLookasideList (&SharedCacheMapLookasideList,
                                      NULL,
                                      NULL,
                                      0,
-                                     sizeof(BCB),
+                                     sizeof(ROS_SHARED_CACHE_MAP),
                                      TAG_BCB,
                                      20);
     ExInitializeNPagedLookasideList (&VacbLookasideList,

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

diff --git a/reactos/ntoskrnl/mm/section.c b/reactos/ntoskrnl/mm/section.c
index acde62a..268e657 100644 (file)
--- a/reactos/ntoskrnl/mm/section.c
+++ b/reactos/ntoskrnl/mm/section.c
@@ -896,7 +896,7 @@ MmUnsharePageEntrySectionSegment(PROS_SECTION_OBJECT Section,
    {
       PFILE_OBJECT FileObject;
 #ifndef NEWCC
-      PBCB Bcb;
+      PROS_SHARED_CACHE_MAP SharedCacheMap;
 #endif
       SWAPENTRY SavedSwapEntry;
       PFN_NUMBER Page;
@@ -918,10 +918,10 @@ MmUnsharePageEntrySectionSegment(PROS_SECTION_OBJECT Section,
                (Offset->QuadPart + PAGE_SIZE <= Segment->RawLength.QuadPart || !IsImageSection))
          {
             NTSTATUS Status;
-            Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
+            SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
             IsDirectMapped = TRUE;
 #ifndef NEWCC
-            Status = CcRosUnmapVacb(Bcb, FileOffset.LowPart, Dirty);
+            Status = CcRosUnmapVacb(SharedCacheMap, FileOffset.LowPart, Dirty);
 #else
             Status = STATUS_SUCCESS;
 #endif
@@ -1015,13 +1015,13 @@ BOOLEAN MiIsPageFromCache(PMEMORY_AREA MemoryArea,
 #ifndef NEWCC
    if (!(MemoryArea->Data.SectionData.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
    {
-      PBCB Bcb;
+      PROS_SHARED_CACHE_MAP SharedCacheMap;
       PROS_VACB Vacb;
-      Bcb = MemoryArea->Data.SectionData.Section->FileObject->SectionObjectPointer->SharedCacheMap;
-      Vacb = CcRosLookupVacb(Bcb, (ULONG)(SegOffset + MemoryArea->Data.SectionData.Segment->Image.FileOffset));
+      SharedCacheMap = MemoryArea->Data.SectionData.Section->FileObject->SectionObjectPointer->SharedCacheMap;
+      Vacb = CcRosLookupVacb(SharedCacheMap, (ULONG)(SegOffset + MemoryArea->Data.SectionData.Segment->Image.FileOffset));
       if (Vacb)
       {
-         CcRosReleaseVacb(Bcb, Vacb, Vacb->Valid, FALSE, TRUE);
+         CcRosReleaseVacb(SharedCacheMap, Vacb, Vacb->Valid, FALSE, TRUE);
          return TRUE;
       }
    }
@@ -1074,17 +1074,17 @@ MiReadPage(PMEMORY_AREA MemoryArea,
    PFILE_OBJECT FileObject;
    NTSTATUS Status;
    ULONG_PTR RawLength;
-   PBCB Bcb;
+   PROS_SHARED_CACHE_MAP SharedCacheMap;
    BOOLEAN IsImageSection;
    ULONG_PTR Length;
 
    FileObject = MemoryArea->Data.SectionData.Section->FileObject;
-   Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
+   SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
    RawLength = (ULONG_PTR)(MemoryArea->Data.SectionData.Segment->RawLength.QuadPart);
    FileOffset = SegOffset + MemoryArea->Data.SectionData.Segment->Image.FileOffset;
    IsImageSection = MemoryArea->Data.SectionData.Section->AllocationAttributes & SEC_IMAGE ? TRUE : FALSE;
 
-   ASSERT(Bcb);
+   ASSERT(SharedCacheMap);
 
    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
        * alignment less than the file system block size.
        */
-      Status = CcRosGetVacb(Bcb,
+      Status = CcRosGetVacb(SharedCacheMap,
                             (ULONG)FileOffset,
                             &BaseOffset,
                             &BaseAddress,
@@ -1122,7 +1122,7 @@ MiReadPage(PMEMORY_AREA MemoryArea,
          Status = CcReadVirtualAddress(Vacb);
          if (!NT_SUCCESS(Status))
          {
-            CcRosReleaseVacb(Bcb, Vacb, FALSE, FALSE, FALSE);
+            CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
             return Status;
          }
       }
@@ -1136,7 +1136,7 @@ MiReadPage(PMEMORY_AREA MemoryArea,
       (*Page) = MmGetPhysicalAddress((char*)BaseAddress +
                                      FileOffset - BaseOffset).LowPart >> PAGE_SHIFT;
 
-      CcRosReleaseVacb(Bcb, Vacb, TRUE, FALSE, TRUE);
+      CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, TRUE);
    }
    else
    {
@@ -1156,7 +1156,7 @@ MiReadPage(PMEMORY_AREA MemoryArea,
       {
          return(Status);
       }
-      Status = CcRosGetVacb(Bcb,
+      Status = CcRosGetVacb(SharedCacheMap,
                             (ULONG)FileOffset,
                             &BaseOffset,
                             &BaseAddress,
@@ -1175,7 +1175,7 @@ MiReadPage(PMEMORY_AREA MemoryArea,
          Status = CcReadVirtualAddress(Vacb);
          if (!NT_SUCCESS(Status))
          {
-            CcRosReleaseVacb(Bcb, Vacb, FALSE, FALSE, FALSE);
+            CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
             return Status;
          }
       }
@@ -1196,8 +1196,8 @@ MiReadPage(PMEMORY_AREA MemoryArea,
       {
          memcpy(PageAddr, (char*)BaseAddress + FileOffset - BaseOffset, VacbOffset);
          MiUnmapPageInHyperSpace(Process, PageAddr, Irql);
-         CcRosReleaseVacb(Bcb, Vacb, TRUE, FALSE, FALSE);
-         Status = CcRosGetVacb(Bcb,
+         CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
+         Status = CcRosGetVacb(SharedCacheMap,
                                (ULONG)(FileOffset + VacbOffset),
                                &BaseOffset,
                                &BaseAddress,
@@ -1216,7 +1216,7 @@ MiReadPage(PMEMORY_AREA MemoryArea,
             Status = CcReadVirtualAddress(Vacb);
             if (!NT_SUCCESS(Status))
             {
-               CcRosReleaseVacb(Bcb, Vacb, FALSE, FALSE, FALSE);
+               CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
                return Status;
             }
          }
@@ -1231,7 +1231,7 @@ MiReadPage(PMEMORY_AREA MemoryArea,
          }
       }
       MiUnmapPageInHyperSpace(Process, PageAddr, Irql);
-      CcRosReleaseVacb(Bcb, Vacb, TRUE, FALSE, FALSE);
+      CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
    }
    return(STATUS_SUCCESS);
 }
@@ -1869,7 +1869,7 @@ MmPageOutSectionView(PMMSUPPORT AddressSpace,
    NTSTATUS Status;
    PFILE_OBJECT FileObject;
 #ifndef NEWCC
-   PBCB Bcb = NULL;
+   PROS_SHARED_CACHE_MAP SharedCacheMap = NULL;
 #endif
    BOOLEAN DirectMapped;
    BOOLEAN IsImageSection;
@@ -1901,7 +1901,7 @@ MmPageOutSectionView(PMMSUPPORT AddressSpace,
    if (FileObject != NULL &&
        !(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
@@ -2066,7 +2066,7 @@ MmPageOutSectionView(PMMSUPPORT AddressSpace,
          KeBugCheckEx(MEMORY_MANAGEMENT, STATUS_UNSUCCESSFUL, SwapEntry, (ULONG_PTR)Process, (ULONG_PTR)Address);
       }
 #ifndef NEWCC
-      Status = CcRosUnmapVacb(Bcb, (ULONG)FileOffset, FALSE);
+      Status = CcRosUnmapVacb(SharedCacheMap, (ULONG)FileOffset, FALSE);
 #else
       Status = STATUS_SUCCESS;
 #endif
@@ -2074,7 +2074,7 @@ MmPageOutSectionView(PMMSUPPORT AddressSpace,
       if (!NT_SUCCESS(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
       MiSetPageEvent(NULL, NULL);
@@ -2276,7 +2276,7 @@ MmWritePageSectionView(PMMSUPPORT AddressSpace,
    BOOLEAN Private;
    NTSTATUS Status;
    PFILE_OBJECT FileObject;
-   PBCB Bcb = NULL;
+   PROS_SHARED_CACHE_MAP SharedCacheMap = NULL;
    BOOLEAN DirectMapped;
    BOOLEAN IsImageSection;
    PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace);
@@ -2298,7 +2298,7 @@ MmWritePageSectionView(PMMSUPPORT AddressSpace,
    if (FileObject != NULL &&
          !(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
@@ -2366,7 +2366,7 @@ MmWritePageSectionView(PMMSUPPORT AddressSpace,
       ASSERT(SwapEntry == 0);
       //SOffset.QuadPart = Offset.QuadPart + Segment->Image.FileOffset;
 #ifndef NEWCC
-      CcRosMarkDirtyVacb(Bcb, Offset.LowPart);
+      CcRosMarkDirtyVacb(SharedCacheMap, Offset.LowPart);
 #endif
       MmLockSectionSegment(Segment);
       MmSetPageEntrySectionSegment(Segment, &Offset, PageEntry);
@@ -3970,7 +3970,7 @@ MmFreeSectionPage(PVOID Context, MEMORY_AREA* MemoryArea, PVOID Address,
 {
    ULONG_PTR Entry;
    PFILE_OBJECT FileObject;
-   PBCB Bcb;
+   PROS_SHARED_CACHE_MAP SharedCacheMap;
    LARGE_INTEGER Offset;
    SWAPENTRY SavedSwapEntry;
    PROS_SECTION_OBJECT Section;
@@ -4011,9 +4011,9 @@ MmFreeSectionPage(PVOID Context, MEMORY_AREA* MemoryArea, PVOID Address,
       if (Page == PFN_FROM_SSE(Entry) && Dirty)
       {
          FileObject = MemoryArea->Data.SectionData.Section->FileObject;
-         Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
+         SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
 #ifndef NEWCC
-         CcRosMarkDirtyVacb(Bcb, (ULONG)(Offset.QuadPart + Segment->Image.FileOffset));
+         CcRosMarkDirtyVacb(SharedCacheMap, (ULONG)(Offset.QuadPart + Segment->Image.FileOffset));
 #endif
          ASSERT(SwapEntry == 0);
       }
@@ -4674,8 +4674,8 @@ MmCanFileBeTruncated (IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
           /* Check size of file */
           if (SectionObjectPointer->SharedCacheMap)
           {
-             PBCB Bcb = SectionObjectPointer->SharedCacheMap;
-             if (NewFileSize->QuadPart <= Bcb->FileSize.QuadPart)
+             PROS_SHARED_CACHE_MAP SharedCacheMap = SectionObjectPointer->SharedCacheMap;
+             if (NewFileSize->QuadPart <= SharedCacheMap->FileSize.QuadPart)
              {
                 return FALSE;
              }