[NTOSKRNL]
[reactos.git] / reactos / ntoskrnl / cc / view.c
index b55b4ad..dc12c7f 100644 (file)
@@ -58,7 +58,7 @@ ULONG DirtyPageCount=0;
 KGUARDED_MUTEX ViewLock;
 
 #ifdef CACHE_BITMAP
-#define        CI_CACHESEG_MAPPING_REGION_SIZE (128*1024*1024)
+#define    CI_CACHESEG_MAPPING_REGION_SIZE    (128*1024*1024)
 
 static PVOID CiCacheSegMappingRegionBase = NULL;
 static RTL_BITMAP CiCacheSegMappingRegionAllocMap;
@@ -73,21 +73,21 @@ static NPAGED_LOOKASIDE_LIST CacheSegLookasideList;
 #if DBG
 static void CcRosCacheSegmentIncRefCount_ ( PCACHE_SEGMENT cs, const char* file, int line )
 {
-       ++cs->ReferenceCount;
-       if ( cs->Bcb->Trace )
-       {
-               DbgPrint("(%s:%i) CacheSegment %p ++RefCount=%d, Dirty %d, PageOut %d\n",
-                       file, line, cs, cs->ReferenceCount, cs->Dirty, cs->PageOut );
-       }
+    ++cs->ReferenceCount;
+    if ( cs->Bcb->Trace )
+    {
+        DbgPrint("(%s:%i) CacheSegment %p ++RefCount=%d, Dirty %d, PageOut %d\n",
+                 file, line, cs, cs->ReferenceCount, cs->Dirty, cs->PageOut );
+    }
 }
 static void CcRosCacheSegmentDecRefCount_ ( PCACHE_SEGMENT cs, const char* file, int line )
 {
-       --cs->ReferenceCount;
-       if ( cs->Bcb->Trace )
-       {
-               DbgPrint("(%s:%i) CacheSegment %p --RefCount=%d, Dirty %d, PageOut %d\n",
-                       file, line, cs, cs->ReferenceCount, cs->Dirty, cs->PageOut );
-       }
+    --cs->ReferenceCount;
+    if ( cs->Bcb->Trace )
+    {
+        DbgPrint("(%s:%i) CacheSegment %p --RefCount=%d, Dirty %d, PageOut %d\n",
+                 file, line, cs, cs->ReferenceCount, cs->Dirty, cs->PageOut );
+    }
 }
 #define CcRosCacheSegmentIncRefCount(cs) CcRosCacheSegmentIncRefCount_(cs,__FILE__,__LINE__)
 #define CcRosCacheSegmentDecRefCount(cs) CcRosCacheSegmentDecRefCount_(cs,__FILE__,__LINE__)
@@ -105,77 +105,81 @@ CcRosInternalFreeCacheSegment(PCACHE_SEGMENT CacheSeg);
 VOID
 NTAPI
 CcRosTraceCacheMap (
-       PBCB Bcb,
-       BOOLEAN Trace )
+    PBCB Bcb,
+    BOOLEAN Trace )
 {
 #if DBG
-       KIRQL oldirql;
-       PLIST_ENTRY current_entry;
-       PCACHE_SEGMENT current;
-
-       if ( !Bcb )
-               return;
-
-       Bcb->Trace = Trace;
-
-       if ( Trace )
-       {
-               DPRINT1("Enabling Tracing for CacheMap 0x%p:\n", Bcb );
-
-               KeAcquireGuardedMutex(&ViewLock);
-               KeAcquireSpinLock(&Bcb->BcbLock, &oldirql);
-
-               current_entry = Bcb->BcbSegmentListHead.Flink;
-               while (current_entry != &Bcb->BcbSegmentListHead)
-               {
-                       current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT, BcbSegmentListEntry);
-                       current_entry = current_entry->Flink;
-
-                       DPRINT1("  CacheSegment 0x%p enabled, RefCount %d, Dirty %d, PageOut %d\n",
-                               current, current->ReferenceCount, current->Dirty, current->PageOut );
-               }
-               KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
-               KeReleaseGuardedMutex(&ViewLock);
-       }
-       else
-       {
-               DPRINT1("Disabling Tracing for CacheMap 0x%p:\n", Bcb );
-       }
+    KIRQL oldirql;
+    PLIST_ENTRY current_entry;
+    PCACHE_SEGMENT current;
+
+    if ( !Bcb )
+        return;
+
+    Bcb->Trace = Trace;
+
+    if ( Trace )
+    {
+        DPRINT1("Enabling Tracing for CacheMap 0x%p:\n", Bcb );
+
+        KeAcquireGuardedMutex(&ViewLock);
+        KeAcquireSpinLock(&Bcb->BcbLock, &oldirql);
+
+        current_entry = Bcb->BcbSegmentListHead.Flink;
+        while (current_entry != &Bcb->BcbSegmentListHead)
+        {
+            current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT, BcbSegmentListEntry);
+            current_entry = current_entry->Flink;
+
+            DPRINT1("  CacheSegment 0x%p enabled, RefCount %d, Dirty %d, PageOut %d\n",
+                    current, current->ReferenceCount, current->Dirty, current->PageOut );
+        }
+        KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
+        KeReleaseGuardedMutex(&ViewLock);
+    }
+    else
+    {
+        DPRINT1("Disabling Tracing for CacheMap 0x%p:\n", Bcb );
+    }
 
 #else
-       Bcb = Bcb;
-       Trace = Trace;
+    Bcb = Bcb;
+    Trace = Trace;
 #endif
 }
 
 NTSTATUS
 NTAPI
-CcRosFlushCacheSegment(PCACHE_SEGMENT CacheSegment)
+CcRosFlushCacheSegment (
+    PCACHE_SEGMENT CacheSegment)
 {
     NTSTATUS Status;
     KIRQL oldIrql;
-    
+
     Status = WriteCacheSegment(CacheSegment);
     if (NT_SUCCESS(Status))
     {
         KeAcquireGuardedMutex(&ViewLock);
         KeAcquireSpinLock(&CacheSegment->Bcb->BcbLock, &oldIrql);
-        
+
         CacheSegment->Dirty = FALSE;
         RemoveEntryList(&CacheSegment->DirtySegmentListEntry);
         DirtyPageCount -= CacheSegment->Bcb->CacheSegmentSize / PAGE_SIZE;
-        CcRosCacheSegmentDecRefCount ( CacheSegment );
-        
+        CcRosCacheSegmentDecRefCount(CacheSegment);
+
         KeReleaseSpinLock(&CacheSegment->Bcb->BcbLock, oldIrql);
         KeReleaseGuardedMutex(&ViewLock);
     }
-    
+
     return(Status);
 }
 
 NTSTATUS
 NTAPI
-CcRosFlushDirtyPages(ULONG Target, PULONG Count, BOOLEAN Wait)
+CcRosFlushDirtyPages (
+    ULONG Target,
+    PULONG Count,
+    BOOLEAN Wait)
 {
     PLIST_ENTRY current_entry;
     PCACHE_SEGMENT current;
@@ -183,22 +187,22 @@ CcRosFlushDirtyPages(ULONG Target, PULONG Count, BOOLEAN Wait)
     BOOLEAN Locked;
     NTSTATUS Status;
     LARGE_INTEGER ZeroTimeout;
-    
+
     DPRINT("CcRosFlushDirtyPages(Target %d)\n", Target);
-    
+
     (*Count) = 0;
     ZeroTimeout.QuadPart = 0;
-    
+
     KeEnterCriticalRegion();
     KeAcquireGuardedMutex(&ViewLock);
-    
+
     current_entry = DirtySegmentListHead.Flink;
     if (current_entry == &DirtySegmentListHead)
     {
         DPRINT("No Dirty pages\n");
     }
-    
-    while (current_entry != &DirtySegmentListHead && Target > 0)
+
+    while ((current_entry != &DirtySegmentListHead) && (Target > 0))
     {
         current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
                                     DirtySegmentListEntry);
@@ -207,7 +211,7 @@ CcRosFlushDirtyPages(ULONG Target, PULONG Count, BOOLEAN Wait)
         CcRosCacheSegmentIncRefCount(current);
 
         Locked = current->Bcb->Callbacks->AcquireForLazyWrite(
-            current->Bcb->LazyWriteContext, Wait);
+                     current->Bcb->LazyWriteContext, Wait);
         if (!Locked)
         {
             CcRosCacheSegmentDecRefCount(current);
@@ -248,7 +252,7 @@ CcRosFlushDirtyPages(ULONG Target, PULONG Count, BOOLEAN Wait)
         KeReleaseMutex(&current->Mutex, 0);
         current->Bcb->Callbacks->ReleaseFromLazyWrite(
             current->Bcb->LazyWriteContext);
-        
+
         KeAcquireGuardedMutex(&ViewLock);
         CcRosCacheSegmentDecRefCount(current);
 
@@ -264,16 +268,19 @@ CcRosFlushDirtyPages(ULONG Target, PULONG Count, BOOLEAN Wait)
 
         current_entry = DirtySegmentListHead.Flink;
     }
-    
+
     KeReleaseGuardedMutex(&ViewLock);
     KeLeaveCriticalRegion();
-    
+
     DPRINT("CcRosFlushDirtyPages() finished\n");
     return(STATUS_SUCCESS);
 }
 
 NTSTATUS
-CcRosTrimCache(ULONG Target, ULONG Priority, PULONG NrFreed)
+CcRosTrimCache (
+    ULONG Target,
+    ULONG Priority,
+    PULONG NrFreed)
 /*
  * FUNCTION: Try to free some memory from the file cache.
  * ARGUMENTS:
@@ -361,7 +368,7 @@ retry:
     KeReleaseGuardedMutex(&ViewLock);
 
     /* Try flushing pages if we haven't met our target */
-    if (Target > 0 && !FlushedPages)
+    if ((Target > 0) && !FlushedPages)
     {
         /* Flush dirty pages to disk */
         CcRosFlushDirtyPages(Target, &PagesFreed, FALSE);
@@ -394,66 +401,69 @@ retry:
 
 NTSTATUS
 NTAPI
-CcRosReleaseCacheSegment(PBCB Bcb,
-                        PCACHE_SEGMENT CacheSeg,
-                        BOOLEAN Valid,
-                        BOOLEAN Dirty,
-                        BOOLEAN Mapped)
+CcRosReleaseCacheSegment (
+    PBCB Bcb,
+    PCACHE_SEGMENT CacheSeg,
+    BOOLEAN Valid,
+    BOOLEAN Dirty,
+    BOOLEAN Mapped)
 {
-  BOOLEAN WasDirty;
-  KIRQL oldIrql;
+    BOOLEAN WasDirty;
+    KIRQL oldIrql;
+
+    ASSERT(Bcb);
 
-  ASSERT(Bcb);
+    DPRINT("CcReleaseCacheSegment(Bcb 0x%p, CacheSeg 0x%p, Valid %d)\n",
+           Bcb, CacheSeg, Valid);
 
-  DPRINT("CcReleaseCacheSegment(Bcb 0x%p, CacheSeg 0x%p, Valid %d)\n",
-        Bcb, CacheSeg, Valid);
+    KeAcquireGuardedMutex(&ViewLock);
+    KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
 
-  KeAcquireGuardedMutex(&ViewLock);
-  KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
+    CacheSeg->Valid = Valid;
 
-  CacheSeg->Valid = Valid;
+    WasDirty = CacheSeg->Dirty;
+    CacheSeg->Dirty = CacheSeg->Dirty || Dirty;
 
-  WasDirty = CacheSeg->Dirty;
-  CacheSeg->Dirty = CacheSeg->Dirty || Dirty;
+    if (!WasDirty && CacheSeg->Dirty)
+    {
+        InsertTailList(&DirtySegmentListHead, &CacheSeg->DirtySegmentListEntry);
+        DirtyPageCount += Bcb->CacheSegmentSize / PAGE_SIZE;
+    }
 
-  if (!WasDirty && CacheSeg->Dirty)
+    if (Mapped)
     {
-      InsertTailList(&DirtySegmentListHead, &CacheSeg->DirtySegmentListEntry);
-      DirtyPageCount += Bcb->CacheSegmentSize / PAGE_SIZE;
+        CacheSeg->MappedCount++;
+    }
+    CcRosCacheSegmentDecRefCount(CacheSeg);
+    if (Mapped && (CacheSeg->MappedCount == 1))
+    {
+        CcRosCacheSegmentIncRefCount(CacheSeg);
+    }
+    if (!WasDirty && CacheSeg->Dirty)
+    {
+        CcRosCacheSegmentIncRefCount(CacheSeg);
     }
 
-  if (Mapped)
-  {
-     CacheSeg->MappedCount++;
-  }
-  CcRosCacheSegmentDecRefCount(CacheSeg);
-  if (Mapped && CacheSeg->MappedCount == 1)
-  {
-      CcRosCacheSegmentIncRefCount(CacheSeg);
-  }
-  if (!WasDirty && CacheSeg->Dirty)
-  {
-      CcRosCacheSegmentIncRefCount(CacheSeg);
-  }
-
-  KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
-  KeReleaseGuardedMutex(&ViewLock);
-  KeReleaseMutex(&CacheSeg->Mutex, 0);
-
-  return(STATUS_SUCCESS);
+    KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+    KeReleaseGuardedMutex(&ViewLock);
+    KeReleaseMutex(&CacheSeg->Mutex, 0);
+
+    return(STATUS_SUCCESS);
 }
 
 /* Returns with Cache Segment Lock Held! */
 PCACHE_SEGMENT
 NTAPI
-CcRosLookupCacheSegment(PBCB Bcb, ULONG FileOffset)
+CcRosLookupCacheSegment (
+    PBCB Bcb,
+    ULONG FileOffset)
 {
     PLIST_ENTRY current_entry;
     PCACHE_SEGMENT current;
     KIRQL oldIrql;
-    
+
     ASSERT(Bcb);
-    
+
     DPRINT("CcRosLookupCacheSegment(Bcb -x%p, FileOffset %d)\n", Bcb, FileOffset);
 
     KeAcquireGuardedMutex(&ViewLock);
@@ -464,8 +474,8 @@ CcRosLookupCacheSegment(PBCB Bcb, ULONG FileOffset)
     {
         current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
                                     BcbSegmentListEntry);
-        if (current->FileOffset <= FileOffset &&
-            (current->FileOffset + Bcb->CacheSegmentSize) > FileOffset)
+        if ((current->FileOffset <= FileOffset) &&
+            ((current->FileOffset + Bcb->CacheSegmentSize) > FileOffset))
         {
             CcRosCacheSegmentIncRefCount(current);
             KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
@@ -488,525 +498,546 @@ CcRosLookupCacheSegment(PBCB Bcb, ULONG FileOffset)
 
 NTSTATUS
 NTAPI
-CcRosMarkDirtyCacheSegment(PBCB Bcb, ULONG FileOffset)
+CcRosMarkDirtyCacheSegment (
+    PBCB Bcb,
+    ULONG FileOffset)
 {
-  PCACHE_SEGMENT CacheSeg;
-  KIRQL oldIrql;
+    PCACHE_SEGMENT CacheSeg;
+    KIRQL oldIrql;
 
-  ASSERT(Bcb);
+    ASSERT(Bcb);
 
-  DPRINT("CcRosMarkDirtyCacheSegment(Bcb 0x%p, FileOffset %d)\n", Bcb, FileOffset);
+    DPRINT("CcRosMarkDirtyCacheSegment(Bcb 0x%p, FileOffset %d)\n", Bcb, FileOffset);
 
-  CacheSeg = CcRosLookupCacheSegment(Bcb, FileOffset);
-  if (CacheSeg == NULL)
+    CacheSeg = CcRosLookupCacheSegment(Bcb, FileOffset);
+    if (CacheSeg == NULL)
     {
-      KeBugCheck(CACHE_MANAGER);
+        KeBugCheck(CACHE_MANAGER);
     }
 
-  KeAcquireGuardedMutex(&ViewLock);
-  KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
+    KeAcquireGuardedMutex(&ViewLock);
+    KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
 
-  if (!CacheSeg->Dirty)
-  {
-      InsertTailList(&DirtySegmentListHead, &CacheSeg->DirtySegmentListEntry);
-      DirtyPageCount += Bcb->CacheSegmentSize / PAGE_SIZE;
-  }
-  else
-  {
-      CcRosCacheSegmentDecRefCount(CacheSeg);
-  }
+    if (!CacheSeg->Dirty)
+    {
+        InsertTailList(&DirtySegmentListHead, &CacheSeg->DirtySegmentListEntry);
+        DirtyPageCount += Bcb->CacheSegmentSize / PAGE_SIZE;
+    }
+    else
+    {
+        CcRosCacheSegmentDecRefCount(CacheSeg);
+    }
 
-  /* Move to the tail of the LRU list */
-  RemoveEntryList(&CacheSeg->CacheSegmentLRUListEntry);
-  InsertTailList(&CacheSegmentLRUListHead, &CacheSeg->CacheSegmentLRUListEntry);
+    /* Move to the tail of the LRU list */
+    RemoveEntryList(&CacheSeg->CacheSegmentLRUListEntry);
+    InsertTailList(&CacheSegmentLRUListHead, &CacheSeg->CacheSegmentLRUListEntry);
 
-  CacheSeg->Dirty = TRUE;
+    CacheSeg->Dirty = TRUE;
 
-  KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
-  KeReleaseGuardedMutex(&ViewLock);
-  KeReleaseMutex(&CacheSeg->Mutex, 0);
+    KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+    KeReleaseGuardedMutex(&ViewLock);
+    KeReleaseMutex(&CacheSeg->Mutex, 0);
 
-  return(STATUS_SUCCESS);
+    return(STATUS_SUCCESS);
 }
 
 NTSTATUS
 NTAPI
-CcRosUnmapCacheSegment(PBCB Bcb, ULONG FileOffset, BOOLEAN NowDirty)
+CcRosUnmapCacheSegment (
+    PBCB Bcb,
+    ULONG FileOffset,
+    BOOLEAN NowDirty)
 {
-  PCACHE_SEGMENT CacheSeg;
-  BOOLEAN WasDirty;
-  KIRQL oldIrql;
+    PCACHE_SEGMENT CacheSeg;
+    BOOLEAN WasDirty;
+    KIRQL oldIrql;
 
-  ASSERT(Bcb);
+    ASSERT(Bcb);
 
-  DPRINT("CcRosUnmapCacheSegment(Bcb 0x%p, FileOffset %d, NowDirty %d)\n",
-          Bcb, FileOffset, NowDirty);
+    DPRINT("CcRosUnmapCacheSegment(Bcb 0x%p, FileOffset %d, NowDirty %d)\n",
+           Bcb, FileOffset, NowDirty);
 
-  CacheSeg = CcRosLookupCacheSegment(Bcb, FileOffset);
-  if (CacheSeg == NULL)
+    CacheSeg = CcRosLookupCacheSegment(Bcb, FileOffset);
+    if (CacheSeg == NULL)
     {
-      return(STATUS_UNSUCCESSFUL);
+        return(STATUS_UNSUCCESSFUL);
     }
 
-  KeAcquireGuardedMutex(&ViewLock);
-  KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
+    KeAcquireGuardedMutex(&ViewLock);
+    KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
 
-  WasDirty = CacheSeg->Dirty;
-  CacheSeg->Dirty = CacheSeg->Dirty || NowDirty;
+    WasDirty = CacheSeg->Dirty;
+    CacheSeg->Dirty = CacheSeg->Dirty || NowDirty;
 
-  CacheSeg->MappedCount--;
+    CacheSeg->MappedCount--;
 
-  if (!WasDirty && NowDirty)
-  {
-     InsertTailList(&DirtySegmentListHead, &CacheSeg->DirtySegmentListEntry);
-     DirtyPageCount += Bcb->CacheSegmentSize / PAGE_SIZE;
-  }
+    if (!WasDirty && NowDirty)
+    {
+        InsertTailList(&DirtySegmentListHead, &CacheSeg->DirtySegmentListEntry);
+        DirtyPageCount += Bcb->CacheSegmentSize / PAGE_SIZE;
+    }
 
-  CcRosCacheSegmentDecRefCount(CacheSeg);
-  if (!WasDirty && NowDirty)
-  {
-     CcRosCacheSegmentIncRefCount(CacheSeg);
-  }
-  if (CacheSeg->MappedCount == 0)
-  {
-     CcRosCacheSegmentDecRefCount(CacheSeg);
-  }
+    CcRosCacheSegmentDecRefCount(CacheSeg);
+    if (!WasDirty && NowDirty)
+    {
+        CcRosCacheSegmentIncRefCount(CacheSeg);
+    }
+    if (CacheSeg->MappedCount == 0)
+    {
+        CcRosCacheSegmentDecRefCount(CacheSeg);
+    }
 
-  KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
-  KeReleaseGuardedMutex(&ViewLock);
-  KeReleaseMutex(&CacheSeg->Mutex, 0);
+    KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+    KeReleaseGuardedMutex(&ViewLock);
+    KeReleaseMutex(&CacheSeg->Mutex, 0);
 
-  return(STATUS_SUCCESS);
+    return(STATUS_SUCCESS);
 }
 
 static
 NTSTATUS
-CcRosCreateCacheSegment(PBCB Bcb,
-                       ULONG FileOffset,
-                       PCACHE_SEGMENT* CacheSeg)
+CcRosCreateCacheSegment (
+    PBCB Bcb,
+    ULONG FileOffset,
+    PCACHE_SEGMENT* CacheSeg)
 {
-  PCACHE_SEGMENT current;
-  PCACHE_SEGMENT previous;
-  PLIST_ENTRY current_entry;
-  NTSTATUS Status;
-  KIRQL oldIrql;
+    PCACHE_SEGMENT current;
+    PCACHE_SEGMENT previous;
+    PLIST_ENTRY current_entry;
+    NTSTATUS Status;
+    KIRQL oldIrql;
 #ifdef CACHE_BITMAP
-  ULONG StartingOffset;
+    ULONG StartingOffset;
 #endif
-  PHYSICAL_ADDRESS BoundaryAddressMultiple;
+    PHYSICAL_ADDRESS BoundaryAddressMultiple;
 
-  ASSERT(Bcb);
+    ASSERT(Bcb);
 
-  DPRINT("CcRosCreateCacheSegment()\n");
+    DPRINT("CcRosCreateCacheSegment()\n");
 
-  BoundaryAddressMultiple.QuadPart = 0;
-  if (FileOffset >= Bcb->FileSize.u.LowPart)
-  {
-     CacheSeg = NULL;
-     return STATUS_INVALID_PARAMETER;
-  }
+    BoundaryAddressMultiple.QuadPart = 0;
+    if (FileOffset >= Bcb->FileSize.u.LowPart)
+    {
+        CacheSeg = NULL;
+        return STATUS_INVALID_PARAMETER;
+    }
 
-  current = ExAllocateFromNPagedLookasideList(&CacheSegLookasideList);
-  current->Valid = FALSE;
-  current->Dirty = FALSE;
-  current->PageOut = FALSE;
-  current->FileOffset = ROUND_DOWN(FileOffset, Bcb->CacheSegmentSize);
-  current->Bcb = Bcb;
-#if DBG
-  if ( Bcb->Trace )
-  {
-    DPRINT1("CacheMap 0x%p: new Cache Segment: 0x%p\n", Bcb, current );
-  }
-#endif
-  current->MappedCount = 0;
-  current->DirtySegmentListEntry.Flink = NULL;
-  current->DirtySegmentListEntry.Blink = NULL;
-  current->ReferenceCount = 1;
-  KeInitializeMutex(&current->Mutex, 0);
-  KeWaitForSingleObject(&current->Mutex,
-                        Executive,
-                        KernelMode,
-                        FALSE,
-                        NULL);
-  KeAcquireGuardedMutex(&ViewLock);
-
-  *CacheSeg = current;
-  /* There is window between the call to CcRosLookupCacheSegment
-   * and CcRosCreateCacheSegment. We must check if a segment on
-   * the fileoffset exist. If there exist a segment, we release
-   * our new created segment and return the existing one.
-   */
-  KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
-  current_entry = Bcb->BcbSegmentListHead.Flink;
-  previous = NULL;
-  while (current_entry != &Bcb->BcbSegmentListHead)
-  {
-     current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
-                                BcbSegmentListEntry);
-     if (current->FileOffset <= FileOffset &&
-       (current->FileOffset + Bcb->CacheSegmentSize) > FileOffset)
-     {
-       CcRosCacheSegmentIncRefCount(current);
-       KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+    current = ExAllocateFromNPagedLookasideList(&CacheSegLookasideList);
+    current->Valid = FALSE;
+    current->Dirty = FALSE;
+    current->PageOut = FALSE;
+    current->FileOffset = ROUND_DOWN(FileOffset, Bcb->CacheSegmentSize);
+    current->Bcb = Bcb;
 #if DBG
-       if ( Bcb->Trace )
-       {
-               DPRINT1("CacheMap 0x%p: deleting newly created Cache Segment 0x%p ( found existing one 0x%p )\n",
-                       Bcb,
-                       (*CacheSeg),
-                       current );
-       }
+    if ( Bcb->Trace )
+    {
+        DPRINT1("CacheMap 0x%p: new Cache Segment: 0x%p\n", Bcb, current );
+    }
 #endif
-       KeReleaseMutex(&(*CacheSeg)->Mutex, 0);
-       KeReleaseGuardedMutex(&ViewLock);
-       ExFreeToNPagedLookasideList(&CacheSegLookasideList, *CacheSeg);
-       *CacheSeg = current;
+    current->MappedCount = 0;
+    current->DirtySegmentListEntry.Flink = NULL;
+    current->DirtySegmentListEntry.Blink = NULL;
+    current->ReferenceCount = 1;
+    KeInitializeMutex(&current->Mutex, 0);
     KeWaitForSingleObject(&current->Mutex,
                           Executive,
                           KernelMode,
                           FALSE,
                           NULL);
-       return STATUS_SUCCESS;
-     }
-     if (current->FileOffset < FileOffset)
-     {
-        if (previous == NULL)
-       {
-          previous = current;
-       }
-       else
-       {
-          if (previous->FileOffset < current->FileOffset)
-          {
-             previous = current;
-          }
-       }
-     }
-     current_entry = current_entry->Flink;
-  }
-  /* There was no existing segment. */
-  current = *CacheSeg;
-  if (previous)
-  {
-     InsertHeadList(&previous->BcbSegmentListEntry, &current->BcbSegmentListEntry);
-  }
-  else
-  {
-     InsertHeadList(&Bcb->BcbSegmentListHead, &current->BcbSegmentListEntry);
-  }
-  KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
-  InsertTailList(&CacheSegmentListHead, &current->CacheSegmentListEntry);
-  InsertTailList(&CacheSegmentLRUListHead, &current->CacheSegmentLRUListEntry);
-  KeReleaseGuardedMutex(&ViewLock);
+    KeAcquireGuardedMutex(&ViewLock);
+
+    *CacheSeg = current;
+    /* There is window between the call to CcRosLookupCacheSegment
+     * and CcRosCreateCacheSegment. We must check if a segment on
+     * the fileoffset exist. If there exist a segment, we release
+     * our new created segment and return the existing one.
+     */
+    KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
+    current_entry = Bcb->BcbSegmentListHead.Flink;
+    previous = NULL;
+    while (current_entry != &Bcb->BcbSegmentListHead)
+    {
+        current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
+                                    BcbSegmentListEntry);
+        if (current->FileOffset <= FileOffset &&
+                (current->FileOffset + Bcb->CacheSegmentSize) > FileOffset)
+        {
+            CcRosCacheSegmentIncRefCount(current);
+            KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+#if DBG
+            if ( Bcb->Trace )
+            {
+                DPRINT1("CacheMap 0x%p: deleting newly created Cache Segment 0x%p ( found existing one 0x%p )\n",
+                        Bcb,
+                        (*CacheSeg),
+                        current );
+            }
+#endif
+            KeReleaseMutex(&(*CacheSeg)->Mutex, 0);
+            KeReleaseGuardedMutex(&ViewLock);
+            ExFreeToNPagedLookasideList(&CacheSegLookasideList, *CacheSeg);
+            *CacheSeg = current;
+            KeWaitForSingleObject(&current->Mutex,
+                                  Executive,
+                                  KernelMode,
+                                  FALSE,
+                                  NULL);
+            return STATUS_SUCCESS;
+        }
+        if (current->FileOffset < FileOffset)
+        {
+            if (previous == NULL)
+            {
+                previous = current;
+            }
+            else
+            {
+                if (previous->FileOffset < current->FileOffset)
+                {
+                    previous = current;
+                }
+            }
+        }
+        current_entry = current_entry->Flink;
+    }
+    /* There was no existing segment. */
+    current = *CacheSeg;
+    if (previous)
+    {
+        InsertHeadList(&previous->BcbSegmentListEntry, &current->BcbSegmentListEntry);
+    }
+    else
+    {
+        InsertHeadList(&Bcb->BcbSegmentListHead, &current->BcbSegmentListEntry);
+    }
+    KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+    InsertTailList(&CacheSegmentListHead, &current->CacheSegmentListEntry);
+    InsertTailList(&CacheSegmentLRUListHead, &current->CacheSegmentLRUListEntry);
+    KeReleaseGuardedMutex(&ViewLock);
 #ifdef CACHE_BITMAP
-  KeAcquireSpinLock(&CiCacheSegMappingRegionLock, &oldIrql);
+    KeAcquireSpinLock(&CiCacheSegMappingRegionLock, &oldIrql);
 
-  StartingOffset = RtlFindClearBitsAndSet(&CiCacheSegMappingRegionAllocMap, Bcb->CacheSegmentSize / PAGE_SIZE, CiCacheSegMappingRegionHint);
+    StartingOffset = RtlFindClearBitsAndSet(&CiCacheSegMappingRegionAllocMap, Bcb->CacheSegmentSize / PAGE_SIZE, CiCacheSegMappingRegionHint);
 
-  if (StartingOffset == 0xffffffff)
-  {
-     DPRINT1("Out of CacheSeg mapping space\n");
-     KeBugCheck(CACHE_MANAGER);
-  }
+    if (StartingOffset == 0xffffffff)
+    {
+        DPRINT1("Out of CacheSeg mapping space\n");
+        KeBugCheck(CACHE_MANAGER);
+    }
 
-  current->BaseAddress = CiCacheSegMappingRegionBase + StartingOffset * PAGE_SIZE;
+    current->BaseAddress = CiCacheSegMappingRegionBase + StartingOffset * PAGE_SIZE;
 
-  if (CiCacheSegMappingRegionHint == StartingOffset)
-  {
-     CiCacheSegMappingRegionHint += Bcb->CacheSegmentSize / PAGE_SIZE;
-  }
+    if (CiCacheSegMappingRegionHint == StartingOffset)
+    {
+        CiCacheSegMappingRegionHint += Bcb->CacheSegmentSize / PAGE_SIZE;
+    }
 
-  KeReleaseSpinLock(&CiCacheSegMappingRegionLock, oldIrql);
+    KeReleaseSpinLock(&CiCacheSegMappingRegionLock, oldIrql);
 #else
-  MmLockAddressSpace(MmGetKernelAddressSpace());
-  current->BaseAddress = NULL;
-  Status = MmCreateMemoryArea(MmGetKernelAddressSpace(),
-                             0, // nothing checks for cache_segment mareas, so set to 0
-                             &current->BaseAddress,
-                             Bcb->CacheSegmentSize,
-                             PAGE_READWRITE,
-                             (PMEMORY_AREA*)&current->MemoryArea,
-                             FALSE,
-                             0,
-                             BoundaryAddressMultiple);
-  MmUnlockAddressSpace(MmGetKernelAddressSpace());
-  if (!NT_SUCCESS(Status))
-  {
-     KeBugCheck(CACHE_MANAGER);
-  }
+    MmLockAddressSpace(MmGetKernelAddressSpace());
+    current->BaseAddress = NULL;
+    Status = MmCreateMemoryArea(MmGetKernelAddressSpace(),
+                                0, // nothing checks for cache_segment mareas, so set to 0
+                                &current->BaseAddress,
+                                Bcb->CacheSegmentSize,
+                                PAGE_READWRITE,
+                                (PMEMORY_AREA*)&current->MemoryArea,
+                                FALSE,
+                                0,
+                                BoundaryAddressMultiple);
+    MmUnlockAddressSpace(MmGetKernelAddressSpace());
+    if (!NT_SUCCESS(Status))
+    {
+        KeBugCheck(CACHE_MANAGER);
+    }
 #endif
 
-  /* Create a virtual mapping for this memory area */
-  MI_SET_USAGE(MI_USAGE_CACHE);
+    /* Create a virtual mapping for this memory area */
+    MI_SET_USAGE(MI_USAGE_CACHE);
 #if MI_TRACE_PFNS
-  PWCHAR pos = NULL;
-  ULONG len = 0;
-  if ((Bcb->FileObject) && (Bcb->FileObject->FileName.Buffer))
-  {
-    pos = wcsrchr(Bcb->FileObject->FileName.Buffer, '\\');
-    len = wcslen(pos) * sizeof(WCHAR);
-    if (pos) snprintf(MI_PFN_CURRENT_PROCESS_NAME, min(16, len), "%S", pos);
-  }   
+    PWCHAR pos = NULL;
+    ULONG len = 0;
+    if ((Bcb->FileObject) && (Bcb->FileObject->FileName.Buffer))
+    {
+        pos = wcsrchr(Bcb->FileObject->FileName.Buffer, '\\');
+        len = wcslen(pos) * sizeof(WCHAR);
+        if (pos) snprintf(MI_PFN_CURRENT_PROCESS_NAME, min(16, len), "%S", pos);
+    }
 #endif
 
-  MmMapMemoryArea(current->BaseAddress, Bcb->CacheSegmentSize,
-      MC_CACHE, PAGE_READWRITE);
+    MmMapMemoryArea(current->BaseAddress, Bcb->CacheSegmentSize,
+                    MC_CACHE, PAGE_READWRITE);
 
-  return(STATUS_SUCCESS);
+    return(STATUS_SUCCESS);
 }
 
 NTSTATUS
 NTAPI
-CcRosGetCacheSegmentChain(PBCB Bcb,
-                         ULONG FileOffset,
-                         ULONG Length,
-                         PCACHE_SEGMENT* CacheSeg)
+CcRosGetCacheSegmentChain (
+    PBCB Bcb,
+    ULONG FileOffset,
+    ULONG Length,
+    PCACHE_SEGMENT* CacheSeg)
 {
-  PCACHE_SEGMENT current;
-  ULONG i;
-  PCACHE_SEGMENT* CacheSegList;
-  PCACHE_SEGMENT Previous = NULL;
+    PCACHE_SEGMENT current;
+    ULONG i;
+    PCACHE_SEGMENT* CacheSegList;
+    PCACHE_SEGMENT Previous = NULL;
 
-  ASSERT(Bcb);
+    ASSERT(Bcb);
 
-  DPRINT("CcRosGetCacheSegmentChain()\n");
+    DPRINT("CcRosGetCacheSegmentChain()\n");
 
-  Length = ROUND_UP(Length, Bcb->CacheSegmentSize);
+    Length = ROUND_UP(Length, Bcb->CacheSegmentSize);
 
-  CacheSegList = _alloca(sizeof(PCACHE_SEGMENT) *
-                       (Length / Bcb->CacheSegmentSize));
+    CacheSegList = _alloca(sizeof(PCACHE_SEGMENT) *
+                           (Length / Bcb->CacheSegmentSize));
 
-  /*
-   * Look for a cache segment already mapping the same data.
-   */
-  for (i = 0; i < (Length / Bcb->CacheSegmentSize); i++)
+    /*
+     * Look for a cache segment already mapping the same data.
+     */
+    for (i = 0; i < (Length / Bcb->CacheSegmentSize); i++)
     {
-      ULONG CurrentOffset = FileOffset + (i * Bcb->CacheSegmentSize);
-      current = CcRosLookupCacheSegment(Bcb, CurrentOffset);
-      if (current != NULL)
-       {
-         KeAcquireGuardedMutex(&ViewLock);
-
-         /* Move to tail of LRU list */
-         RemoveEntryList(&current->CacheSegmentLRUListEntry);
-         InsertTailList(&CacheSegmentLRUListHead, &current->CacheSegmentLRUListEntry);
-
-         KeReleaseGuardedMutex(&ViewLock);
-
-         CacheSegList[i] = current;
-       }
-      else
-       {
-         CcRosCreateCacheSegment(Bcb, CurrentOffset, &current);
-         CacheSegList[i] = current;
-       }
+        ULONG CurrentOffset = FileOffset + (i * Bcb->CacheSegmentSize);
+        current = CcRosLookupCacheSegment(Bcb, CurrentOffset);
+        if (current != NULL)
+        {
+            KeAcquireGuardedMutex(&ViewLock);
+
+            /* Move to tail of LRU list */
+            RemoveEntryList(&current->CacheSegmentLRUListEntry);
+            InsertTailList(&CacheSegmentLRUListHead, &current->CacheSegmentLRUListEntry);
+
+            KeReleaseGuardedMutex(&ViewLock);
+
+            CacheSegList[i] = current;
+        }
+        else
+        {
+            CcRosCreateCacheSegment(Bcb, CurrentOffset, &current);
+            CacheSegList[i] = current;
+        }
     }
 
-  for (i = 0; i < (Length / Bcb->CacheSegmentSize); i++)
+    for (i = 0; i < (Length / Bcb->CacheSegmentSize); i++)
     {
-      if (i == 0)
-       {
-         *CacheSeg = CacheSegList[i];
-         Previous = CacheSegList[i];
-       }
-      else
-       {
-         Previous->NextInChain = CacheSegList[i];
-         Previous = CacheSegList[i];
-       }
+        if (i == 0)
+        {
+            *CacheSeg = CacheSegList[i];
+            Previous = CacheSegList[i];
+        }
+        else
+        {
+            Previous->NextInChain = CacheSegList[i];
+            Previous = CacheSegList[i];
+        }
     }
-  ASSERT(Previous);
-  Previous->NextInChain = NULL;
+    ASSERT(Previous);
+    Previous->NextInChain = NULL;
 
-  return(STATUS_SUCCESS);
+    return(STATUS_SUCCESS);
 }
 
 NTSTATUS
 NTAPI
-CcRosGetCacheSegment(PBCB Bcb,
-                    ULONG FileOffset,
-                    PULONG BaseOffset,
-                    PVOID* BaseAddress,
-                    PBOOLEAN UptoDate,
-                    PCACHE_SEGMENT* CacheSeg)
+CcRosGetCacheSegment (
+    PBCB Bcb,
+    ULONG FileOffset,
+    PULONG BaseOffset,
+    PVOID* BaseAddress,
+    PBOOLEAN UptoDate,
+    PCACHE_SEGMENT* CacheSeg)
 {
-   PCACHE_SEGMENT current;
-   NTSTATUS Status;
-
-   ASSERT(Bcb);
-
-   DPRINT("CcRosGetCacheSegment()\n");
-
-   /*
-    * Look for a cache segment already mapping the same data.
-    */
-   current = CcRosLookupCacheSegment(Bcb, FileOffset);
-   if (current == NULL)
-   {
-     /*
-      * Otherwise create a new segment.
-      */
-      Status = CcRosCreateCacheSegment(Bcb, FileOffset, &current);
-      if (!NT_SUCCESS(Status))
-      {
-       return Status;
-      }
-   }
-
-   KeAcquireGuardedMutex(&ViewLock);
-
-   /* Move to the tail of the LRU list */
-   RemoveEntryList(&current->CacheSegmentLRUListEntry);
-   InsertTailList(&CacheSegmentLRUListHead, &current->CacheSegmentLRUListEntry);
-
-   KeReleaseGuardedMutex(&ViewLock);
-
-   /*
-    * Return information about the segment to the caller.
-    */
-   *UptoDate = current->Valid;
-   *BaseAddress = current->BaseAddress;
-   DPRINT("*BaseAddress %p\n", *BaseAddress);
-   *CacheSeg = current;
-   *BaseOffset = current->FileOffset;
-   return(STATUS_SUCCESS);
+    PCACHE_SEGMENT current;
+    NTSTATUS Status;
+
+    ASSERT(Bcb);
+
+    DPRINT("CcRosGetCacheSegment()\n");
+
+    /*
+     * Look for a cache segment already mapping the same data.
+     */
+    current = CcRosLookupCacheSegment(Bcb, FileOffset);
+    if (current == NULL)
+    {
+        /*
+         * Otherwise create a new segment.
+         */
+        Status = CcRosCreateCacheSegment(Bcb, FileOffset, &current);
+        if (!NT_SUCCESS(Status))
+        {
+            return Status;
+        }
+    }
+
+    KeAcquireGuardedMutex(&ViewLock);
+
+    /* Move to the tail of the LRU list */
+    RemoveEntryList(&current->CacheSegmentLRUListEntry);
+    InsertTailList(&CacheSegmentLRUListHead, &current->CacheSegmentLRUListEntry);
+
+    KeReleaseGuardedMutex(&ViewLock);
+
+    /*
+     * Return information about the segment to the caller.
+     */
+    *UptoDate = current->Valid;
+    *BaseAddress = current->BaseAddress;
+    DPRINT("*BaseAddress %p\n", *BaseAddress);
+    *CacheSeg = current;
+    *BaseOffset = current->FileOffset;
+    return(STATUS_SUCCESS);
 }
 
-NTSTATUS NTAPI
-CcRosRequestCacheSegment(PBCB Bcb,
-                     ULONG FileOffset,
-                     PVOID* BaseAddress,
-                     PBOOLEAN UptoDate,
-                     PCACHE_SEGMENT* CacheSeg)
+NTSTATUS
+NTAPI
+CcRosRequestCacheSegment (
+    PBCB Bcb,
+    ULONG FileOffset,
+    PVOID* BaseAddress,
+    PBOOLEAN UptoDate,
+    PCACHE_SEGMENT* CacheSeg)
 /*
  * FUNCTION: Request a page mapping for a BCB
  */
 {
-  ULONG BaseOffset;
+    ULONG BaseOffset;
 
-  ASSERT(Bcb);
+    ASSERT(Bcb);
 
-  if ((FileOffset % Bcb->CacheSegmentSize) != 0)
+    if ((FileOffset % Bcb->CacheSegmentSize) != 0)
     {
-      DPRINT1("Bad fileoffset %x should be multiple of %x",
-        FileOffset, Bcb->CacheSegmentSize);
-      KeBugCheck(CACHE_MANAGER);
+        DPRINT1("Bad fileoffset %x should be multiple of %x",
+                FileOffset, Bcb->CacheSegmentSize);
+        KeBugCheck(CACHE_MANAGER);
     }
 
-  return(CcRosGetCacheSegment(Bcb,
-                          FileOffset,
-                          &BaseOffset,
-                          BaseAddress,
-                          UptoDate,
-                          CacheSeg));
+    return(CcRosGetCacheSegment(Bcb,
+                                FileOffset,
+                                &BaseOffset,
+                                BaseAddress,
+                                UptoDate,
+                                CacheSeg));
 }
 #ifdef CACHE_BITMAP
 #else
-static VOID
-CcFreeCachePage(PVOID Context, MEMORY_AREA* MemoryArea, PVOID Address,
-               PFN_NUMBER Page, SWAPENTRY SwapEntry, BOOLEAN Dirty)
+static
+VOID
+CcFreeCachePage (
+    PVOID Context,
+    MEMORY_AREA* MemoryArea,
+    PVOID Address,
+    PFN_NUMBER Page,
+    SWAPENTRY SwapEntry,
+    BOOLEAN Dirty)
 {
-  ASSERT(SwapEntry == 0);
-  if (Page != 0)
+    ASSERT(SwapEntry == 0);
+    if (Page != 0)
     {
         ASSERT(MmGetReferenceCountPage(Page) == 1);
-      MmReleasePageMemoryConsumer(MC_CACHE, Page);
+        MmReleasePageMemoryConsumer(MC_CACHE, Page);
     }
 }
 #endif
 NTSTATUS
-CcRosInternalFreeCacheSegment(PCACHE_SEGMENT CacheSeg)
+CcRosInternalFreeCacheSegment (
+    PCACHE_SEGMENT CacheSeg)
 /*
  * FUNCTION: Releases a cache segment associated with a BCB
  */
 {
 #ifdef CACHE_BITMAP
-  ULONG i;
-  ULONG RegionSize;
-  ULONG Base;
-  PFN_NUMBER Page;
-  KIRQL oldIrql;
+    ULONG i;
+    ULONG RegionSize;
+    ULONG Base;
+    PFN_NUMBER Page;
+    KIRQL oldIrql;
 #endif
-  DPRINT("Freeing cache segment 0x%p\n", CacheSeg);
+    DPRINT("Freeing cache segment 0x%p\n", CacheSeg);
 #if DBG
-       if ( CacheSeg->Bcb->Trace )
-       {
-               DPRINT1("CacheMap 0x%p: deleting Cache Segment: 0x%p\n", CacheSeg->Bcb, CacheSeg );
-       }
+    if ( CacheSeg->Bcb->Trace )
+    {
+        DPRINT1("CacheMap 0x%p: deleting Cache Segment: 0x%p\n", CacheSeg->Bcb, CacheSeg );
+    }
 #endif
 #ifdef CACHE_BITMAP
-  RegionSize = CacheSeg->Bcb->CacheSegmentSize / PAGE_SIZE;
+    RegionSize = CacheSeg->Bcb->CacheSegmentSize / PAGE_SIZE;
 
-  /* Unmap all the pages. */
-  for (i = 0; i < RegionSize; i++)
+    /* Unmap all the pages. */
+    for (i = 0; i < RegionSize; i++)
     {
-      MmDeleteVirtualMapping(NULL,
-                            CacheSeg->BaseAddress + (i * PAGE_SIZE),
-                            FALSE,
-                            NULL,
-                            &Page);
-      MmReleasePageMemoryConsumer(MC_CACHE, Page);
+        MmDeleteVirtualMapping(NULL,
+                               CacheSeg->BaseAddress + (i * PAGE_SIZE),
+                               FALSE,
+                               NULL,
+                               &Page);
+        MmReleasePageMemoryConsumer(MC_CACHE, Page);
     }
 
-  KeAcquireSpinLock(&CiCacheSegMappingRegionLock, &oldIrql);
-  /* Deallocate all the pages used. */
-  Base = (ULONG)(CacheSeg->BaseAddress - CiCacheSegMappingRegionBase) / PAGE_SIZE;
+    KeAcquireSpinLock(&CiCacheSegMappingRegionLock, &oldIrql);
+    /* Deallocate all the pages used. */
+    Base = (ULONG)(CacheSeg->BaseAddress - CiCacheSegMappingRegionBase) / PAGE_SIZE;
 
-  RtlClearBits(&CiCacheSegMappingRegionAllocMap, Base, RegionSize);
+    RtlClearBits(&CiCacheSegMappingRegionAllocMap, Base, RegionSize);
 
-  CiCacheSegMappingRegionHint = min (CiCacheSegMappingRegionHint, Base);
+    CiCacheSegMappingRegionHint = min (CiCacheSegMappingRegionHint, Base);
 
-  KeReleaseSpinLock(&CiCacheSegMappingRegionLock, oldIrql);
+    KeReleaseSpinLock(&CiCacheSegMappingRegionLock, oldIrql);
 #else
-  MmLockAddressSpace(MmGetKernelAddressSpace());
-  MmFreeMemoryArea(MmGetKernelAddressSpace(),
-                  CacheSeg->MemoryArea,
-                  CcFreeCachePage,
-                  NULL);
-  MmUnlockAddressSpace(MmGetKernelAddressSpace());
+    MmLockAddressSpace(MmGetKernelAddressSpace());
+    MmFreeMemoryArea(MmGetKernelAddressSpace(),
+                     CacheSeg->MemoryArea,
+                     CcFreeCachePage,
+                     NULL);
+    MmUnlockAddressSpace(MmGetKernelAddressSpace());
 #endif
-  ExFreeToNPagedLookasideList(&CacheSegLookasideList, CacheSeg);
-  return(STATUS_SUCCESS);
+    ExFreeToNPagedLookasideList(&CacheSegLookasideList, CacheSeg);
+    return(STATUS_SUCCESS);
 }
 
 NTSTATUS
 NTAPI
-CcRosFreeCacheSegment(PBCB Bcb, PCACHE_SEGMENT CacheSeg)
+CcRosFreeCacheSegment (
+    PBCB Bcb,
+    PCACHE_SEGMENT CacheSeg)
 {
-  NTSTATUS Status;
-  KIRQL oldIrql;
-
-  ASSERT(Bcb);
-
-  DPRINT("CcRosFreeCacheSegment(Bcb 0x%p, CacheSeg 0x%p)\n",
-         Bcb, CacheSeg);
-
-  KeAcquireGuardedMutex(&ViewLock);
-  KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
-  RemoveEntryList(&CacheSeg->BcbSegmentListEntry);
-  RemoveEntryList(&CacheSeg->CacheSegmentListEntry);
-  RemoveEntryList(&CacheSeg->CacheSegmentLRUListEntry);
-  if (CacheSeg->Dirty)
-  {
-     RemoveEntryList(&CacheSeg->DirtySegmentListEntry);
-     DirtyPageCount -= Bcb->CacheSegmentSize / PAGE_SIZE;
-
-  }
-  KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
-  KeReleaseGuardedMutex(&ViewLock);
-
-  Status = CcRosInternalFreeCacheSegment(CacheSeg);
-  return(Status);
+    NTSTATUS Status;
+    KIRQL oldIrql;
+
+    ASSERT(Bcb);
+
+    DPRINT("CcRosFreeCacheSegment(Bcb 0x%p, CacheSeg 0x%p)\n",
+           Bcb, CacheSeg);
+
+    KeAcquireGuardedMutex(&ViewLock);
+    KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
+    RemoveEntryList(&CacheSeg->BcbSegmentListEntry);
+    RemoveEntryList(&CacheSeg->CacheSegmentListEntry);
+    RemoveEntryList(&CacheSeg->CacheSegmentLRUListEntry);
+    if (CacheSeg->Dirty)
+    {
+        RemoveEntryList(&CacheSeg->DirtySegmentListEntry);
+        DirtyPageCount -= Bcb->CacheSegmentSize / PAGE_SIZE;
+
+    }
+    KeReleaseSpinLock(&Bcb->BcbLock, oldIrql);
+    KeReleaseGuardedMutex(&ViewLock);
+
+    Status = CcRosInternalFreeCacheSegment(CacheSeg);
+    return(Status);
 }
 
 /*
  * @implemented
  */
-VOID NTAPI
-CcFlushCache(IN PSECTION_OBJECT_POINTERS SectionObjectPointers,
-             IN PLARGE_INTEGER FileOffset OPTIONAL,
-             IN ULONG Length,
-             OUT PIO_STATUS_BLOCK IoStatus)
+VOID
+NTAPI
+CcFlushCache (
+    IN PSECTION_OBJECT_POINTERS SectionObjectPointers,
+    IN PLARGE_INTEGER FileOffset OPTIONAL,
+    IN ULONG Length,
+    OUT PIO_STATUS_BLOCK IoStatus)
 {
     PBCB Bcb;
     LARGE_INTEGER Offset;
@@ -1051,7 +1082,7 @@ CcFlushCache(IN PSECTION_OBJECT_POINTERS SectionObjectPointers,
                     }
                 }
                 KeReleaseMutex(&current->Mutex, 0);
-                
+
                 KeAcquireGuardedMutex(&ViewLock);
                 KeAcquireSpinLock(&Bcb->BcbLock, &oldIrql);
                 CcRosCacheSegmentDecRefCount(current);
@@ -1081,7 +1112,9 @@ CcFlushCache(IN PSECTION_OBJECT_POINTERS SectionObjectPointers,
 
 NTSTATUS
 NTAPI
-CcRosDeleteFileCache(PFILE_OBJECT FileObject, PBCB Bcb)
+CcRosDeleteFileCache (
+    PFILE_OBJECT FileObject,
+    PBCB Bcb)
 /*
  * FUNCTION: Releases the BCB associated with a file object
  */
@@ -1152,284 +1185,295 @@ CcRosDeleteFileCache(PFILE_OBJECT FileObject, PBCB Bcb)
 
 VOID
 NTAPI
-CcRosReferenceCache(PFILE_OBJECT FileObject)
+CcRosReferenceCache (
+    PFILE_OBJECT FileObject)
 {
-  PBCB Bcb;
-  KeAcquireGuardedMutex(&ViewLock);
-  Bcb = (PBCB)FileObject->SectionObjectPointer->SharedCacheMap;
-  ASSERT(Bcb);
-  if (Bcb->RefCount == 0)
-  {
-     ASSERT(Bcb->BcbRemoveListEntry.Flink != NULL);
-     RemoveEntryList(&Bcb->BcbRemoveListEntry);
-     Bcb->BcbRemoveListEntry.Flink = NULL;
-
-  }
-  else
-  {
-     ASSERT(Bcb->BcbRemoveListEntry.Flink == NULL);
-  }
-  Bcb->RefCount++;
-  KeReleaseGuardedMutex(&ViewLock);
+    PBCB Bcb;
+    KeAcquireGuardedMutex(&ViewLock);
+    Bcb = (PBCB)FileObject->SectionObjectPointer->SharedCacheMap;
+    ASSERT(Bcb);
+    if (Bcb->RefCount == 0)
+    {
+        ASSERT(Bcb->BcbRemoveListEntry.Flink != NULL);
+        RemoveEntryList(&Bcb->BcbRemoveListEntry);
+        Bcb->BcbRemoveListEntry.Flink = NULL;
+
+    }
+    else
+    {
+        ASSERT(Bcb->BcbRemoveListEntry.Flink == NULL);
+    }
+    Bcb->RefCount++;
+    KeReleaseGuardedMutex(&ViewLock);
 }
 
 VOID
 NTAPI
-CcRosSetRemoveOnClose(PSECTION_OBJECT_POINTERS SectionObjectPointer)
+CcRosSetRemoveOnClose (
+    PSECTION_OBJECT_POINTERS SectionObjectPointer)
 {
-  PBCB Bcb;
-  DPRINT("CcRosSetRemoveOnClose()\n");
-  KeAcquireGuardedMutex(&ViewLock);
-  Bcb = (PBCB)SectionObjectPointer->SharedCacheMap;
-  if (Bcb)
-  {
-    Bcb->RemoveOnClose = TRUE;
-    if (Bcb->RefCount == 0)
+    PBCB Bcb;
+    DPRINT("CcRosSetRemoveOnClose()\n");
+    KeAcquireGuardedMutex(&ViewLock);
+    Bcb = (PBCB)SectionObjectPointer->SharedCacheMap;
+    if (Bcb)
     {
-      CcRosDeleteFileCache(Bcb->FileObject, Bcb);
+        Bcb->RemoveOnClose = TRUE;
+        if (Bcb->RefCount == 0)
+        {
+            CcRosDeleteFileCache(Bcb->FileObject, Bcb);
+        }
     }
-  }
-  KeReleaseGuardedMutex(&ViewLock);
+    KeReleaseGuardedMutex(&ViewLock);
 }
 
 
 VOID
 NTAPI
-CcRosDereferenceCache(PFILE_OBJECT FileObject)
+CcRosDereferenceCache (
+    PFILE_OBJECT FileObject)
 {
-  PBCB Bcb;
-  KeAcquireGuardedMutex(&ViewLock);
-  Bcb = (PBCB)FileObject->SectionObjectPointer->SharedCacheMap;
-  ASSERT(Bcb);
-  if (Bcb->RefCount > 0)
-  {
-    Bcb->RefCount--;
-    if (Bcb->RefCount == 0)
+    PBCB Bcb;
+    KeAcquireGuardedMutex(&ViewLock);
+    Bcb = (PBCB)FileObject->SectionObjectPointer->SharedCacheMap;
+    ASSERT(Bcb);
+    if (Bcb->RefCount > 0)
     {
-       MmFreeSectionSegments(Bcb->FileObject);
-          CcRosDeleteFileCache(FileObject, Bcb);
+        Bcb->RefCount--;
+        if (Bcb->RefCount == 0)
+        {
+            MmFreeSectionSegments(Bcb->FileObject);
+            CcRosDeleteFileCache(FileObject, Bcb);
+        }
     }
-  }
-  KeReleaseGuardedMutex(&ViewLock);
+    KeReleaseGuardedMutex(&ViewLock);
 }
 
-NTSTATUS NTAPI
-CcRosReleaseFileCache(PFILE_OBJECT FileObject)
+NTSTATUS
+NTAPI
+CcRosReleaseFileCache (
+    PFILE_OBJECT FileObject)
 /*
  * FUNCTION: Called by the file system when a handle to a file object
  * has been closed.
  */
 {
-  PBCB Bcb;
+    PBCB Bcb;
 
-  KeAcquireGuardedMutex(&ViewLock);
+    KeAcquireGuardedMutex(&ViewLock);
 
-  if (FileObject->SectionObjectPointer->SharedCacheMap != NULL)
-  {
-    Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
-    if (FileObject->PrivateCacheMap != NULL)
+    if (FileObject->SectionObjectPointer->SharedCacheMap != NULL)
     {
-      FileObject->PrivateCacheMap = NULL;
-      if (Bcb->RefCount > 0)
-      {
-         Bcb->RefCount--;
-        if (Bcb->RefCount == 0)
-        {
-            MmFreeSectionSegments(Bcb->FileObject);
-              CcRosDeleteFileCache(FileObject, Bcb);
-        }
-      }
+        Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
+        if (FileObject->PrivateCacheMap != NULL)
+        {
+            FileObject->PrivateCacheMap = NULL;
+            if (Bcb->RefCount > 0)
+            {
+                Bcb->RefCount--;
+                if (Bcb->RefCount == 0)
+                {
+                    MmFreeSectionSegments(Bcb->FileObject);
+                    CcRosDeleteFileCache(FileObject, Bcb);
+                }
+            }
+        }
     }
-  }
-  KeReleaseGuardedMutex(&ViewLock);
-  return(STATUS_SUCCESS);
+    KeReleaseGuardedMutex(&ViewLock);
+    return(STATUS_SUCCESS);
 }
 
 NTSTATUS
 NTAPI
-CcTryToInitializeFileCache(PFILE_OBJECT FileObject)
+CcTryToInitializeFileCache (
+    PFILE_OBJECT FileObject)
 {
-   PBCB Bcb;
-   NTSTATUS Status;
-
-   KeAcquireGuardedMutex(&ViewLock);
-
-   ASSERT(FileObject->SectionObjectPointer);
-   Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
-   if (Bcb == NULL)
-   {
-      Status = STATUS_UNSUCCESSFUL;
-   }
-   else
-   {
-      if (FileObject->PrivateCacheMap == NULL)
-      {
-         FileObject->PrivateCacheMap = Bcb;
-         Bcb->RefCount++;
-      }
-      if (Bcb->BcbRemoveListEntry.Flink != NULL)
-      {
-         RemoveEntryList(&Bcb->BcbRemoveListEntry);
-         Bcb->BcbRemoveListEntry.Flink = NULL;
-      }
-      Status = STATUS_SUCCESS;
-   }
-   KeReleaseGuardedMutex(&ViewLock);
-
-   return Status;
+    PBCB Bcb;
+    NTSTATUS Status;
+
+    KeAcquireGuardedMutex(&ViewLock);
+
+    ASSERT(FileObject->SectionObjectPointer);
+    Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
+    if (Bcb == NULL)
+    {
+        Status = STATUS_UNSUCCESSFUL;
+    }
+    else
+    {
+        if (FileObject->PrivateCacheMap == NULL)
+        {
+            FileObject->PrivateCacheMap = Bcb;
+            Bcb->RefCount++;
+        }
+        if (Bcb->BcbRemoveListEntry.Flink != NULL)
+        {
+            RemoveEntryList(&Bcb->BcbRemoveListEntry);
+            Bcb->BcbRemoveListEntry.Flink = NULL;
+        }
+        Status = STATUS_SUCCESS;
+    }
+    KeReleaseGuardedMutex(&ViewLock);
+
+    return Status;
 }
 
 
-NTSTATUS NTAPI
-CcRosInitializeFileCache(PFILE_OBJECT FileObject,
-                         ULONG CacheSegmentSize,
-                         PCACHE_MANAGER_CALLBACKS CallBacks,
-                         PVOID LazyWriterContext)
+NTSTATUS
+NTAPI
+CcRosInitializeFileCache (
+    PFILE_OBJECT FileObject,
+    ULONG CacheSegmentSize,
+    PCACHE_MANAGER_CALLBACKS CallBacks,
+    PVOID LazyWriterContext)
 /*
  * FUNCTION: Initializes a BCB for a file object
  */
 {
-   PBCB Bcb;
+    PBCB Bcb;
 
-   Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
-   DPRINT("CcRosInitializeFileCache(FileObject 0x%p, Bcb 0x%p, CacheSegmentSize %d)\n",
+    Bcb = FileObject->SectionObjectPointer->SharedCacheMap;
+    DPRINT("CcRosInitializeFileCache(FileObject 0x%p, Bcb 0x%p, CacheSegmentSize %d)\n",
            FileObject, Bcb, CacheSegmentSize);
 
-   KeAcquireGuardedMutex(&ViewLock);
-   if (Bcb == NULL)
-   {
-       Bcb = ExAllocateFromNPagedLookasideList(&BcbLookasideList);
-       if (Bcb == NULL)
-       {
-           KeReleaseGuardedMutex(&ViewLock);
-           return(STATUS_UNSUCCESSFUL);
-       }
-       memset(Bcb, 0, sizeof(BCB));
-       ObReferenceObjectByPointer(FileObject,
-           FILE_ALL_ACCESS,
-           NULL,
-           KernelMode);
-       Bcb->FileObject = FileObject;
-       Bcb->CacheSegmentSize = CacheSegmentSize;
-       Bcb->Callbacks = CallBacks;
-       Bcb->LazyWriteContext = LazyWriterContext;
-       if (FileObject->FsContext)
-       {
-           Bcb->AllocationSize =
-               ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->AllocationSize;
-           Bcb->FileSize =
-               ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->FileSize;
-       }
-       KeInitializeSpinLock(&Bcb->BcbLock);
-       InitializeListHead(&Bcb->BcbSegmentListHead);
-       FileObject->SectionObjectPointer->SharedCacheMap = Bcb;
-   }
-   if (FileObject->PrivateCacheMap == NULL)
-   {
-       FileObject->PrivateCacheMap = Bcb;
-       Bcb->RefCount++;
-   }
-   if (Bcb->BcbRemoveListEntry.Flink != NULL)
-   {
-       RemoveEntryList(&Bcb->BcbRemoveListEntry);
-       Bcb->BcbRemoveListEntry.Flink = NULL;
-   }
-   KeReleaseGuardedMutex(&ViewLock);
-
-   return(STATUS_SUCCESS);
+    KeAcquireGuardedMutex(&ViewLock);
+    if (Bcb == NULL)
+    {
+        Bcb = ExAllocateFromNPagedLookasideList(&BcbLookasideList);
+        if (Bcb == NULL)
+        {
+            KeReleaseGuardedMutex(&ViewLock);
+            return(STATUS_UNSUCCESSFUL);
+        }
+        memset(Bcb, 0, sizeof(BCB));
+        ObReferenceObjectByPointer(FileObject,
+                                   FILE_ALL_ACCESS,
+                                   NULL,
+                                   KernelMode);
+        Bcb->FileObject = FileObject;
+        Bcb->CacheSegmentSize = CacheSegmentSize;
+        Bcb->Callbacks = CallBacks;
+        Bcb->LazyWriteContext = LazyWriterContext;
+        if (FileObject->FsContext)
+        {
+            Bcb->AllocationSize =
+                ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->AllocationSize;
+            Bcb->FileSize =
+                ((PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext)->FileSize;
+        }
+        KeInitializeSpinLock(&Bcb->BcbLock);
+        InitializeListHead(&Bcb->BcbSegmentListHead);
+        FileObject->SectionObjectPointer->SharedCacheMap = Bcb;
+    }
+    if (FileObject->PrivateCacheMap == NULL)
+    {
+        FileObject->PrivateCacheMap = Bcb;
+        Bcb->RefCount++;
+    }
+    if (Bcb->BcbRemoveListEntry.Flink != NULL)
+    {
+        RemoveEntryList(&Bcb->BcbRemoveListEntry);
+        Bcb->BcbRemoveListEntry.Flink = NULL;
+    }
+    KeReleaseGuardedMutex(&ViewLock);
+
+    return(STATUS_SUCCESS);
 }
 
 /*
  * @implemented
  */
-PFILE_OBJECT NTAPI
-CcGetFileObjectFromSectionPtrs(IN PSECTION_OBJECT_POINTERS SectionObjectPointers)
+PFILE_OBJECT
+NTAPI
+CcGetFileObjectFromSectionPtrs (
+    IN PSECTION_OBJECT_POINTERS SectionObjectPointers)
 {
-   PBCB Bcb;
-   if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
-   {
-      Bcb = (PBCB)SectionObjectPointers->SharedCacheMap;
-      ASSERT(Bcb);
-      return Bcb->FileObject;
-   }
-   return NULL;
+    PBCB Bcb;
+    if (SectionObjectPointers && SectionObjectPointers->SharedCacheMap)
+    {
+        Bcb = (PBCB)SectionObjectPointers->SharedCacheMap;
+        ASSERT(Bcb);
+        return Bcb->FileObject;
+    }
+    return NULL;
 }
 
 VOID
 INIT_FUNCTION
 NTAPI
-CcInitView(VOID)
+CcInitView (
+    VOID)
 {
 #ifdef CACHE_BITMAP
-  PMEMORY_AREA marea;
-  PVOID Buffer;
-  PHYSICAL_ADDRESS BoundaryAddressMultiple;
+    PMEMORY_AREA marea;
+    PVOID Buffer;
+    PHYSICAL_ADDRESS BoundaryAddressMultiple;
 #endif
 
-  DPRINT("CcInitView()\n");
+    DPRINT("CcInitView()\n");
 #ifdef CACHE_BITMAP
-  BoundaryAddressMultiple.QuadPart = 0;
-  CiCacheSegMappingRegionHint = 0;
-  CiCacheSegMappingRegionBase = NULL;
-
-  MmLockAddressSpace(MmGetKernelAddressSpace());
-
-  Status = MmCreateMemoryArea(MmGetKernelAddressSpace(),
-                             MEMORY_AREA_CACHE_SEGMENT,
-                             &CiCacheSegMappingRegionBase,
-                             CI_CACHESEG_MAPPING_REGION_SIZE,
-                             PAGE_READWRITE,
-                             &marea,
-                             FALSE,
-                             0,
-                             BoundaryAddressMultiple);
-  MmUnlockAddressSpace(MmGetKernelAddressSpace());
-  if (!NT_SUCCESS(Status))
+    BoundaryAddressMultiple.QuadPart = 0;
+    CiCacheSegMappingRegionHint = 0;
+    CiCacheSegMappingRegionBase = NULL;
+
+    MmLockAddressSpace(MmGetKernelAddressSpace());
+
+    Status = MmCreateMemoryArea(MmGetKernelAddressSpace(),
+                                MEMORY_AREA_CACHE_SEGMENT,
+                                &CiCacheSegMappingRegionBase,
+                                CI_CACHESEG_MAPPING_REGION_SIZE,
+                                PAGE_READWRITE,
+                                &marea,
+                                FALSE,
+                                0,
+                                BoundaryAddressMultiple);
+    MmUnlockAddressSpace(MmGetKernelAddressSpace());
+    if (!NT_SUCCESS(Status))
     {
-      KeBugCheck(CACHE_MANAGER);
+        KeBugCheck(CACHE_MANAGER);
     }
 
-  Buffer = ExAllocatePool(NonPagedPool, CI_CACHESEG_MAPPING_REGION_SIZE / (PAGE_SIZE * 8));
-  if (!Buffer)
-  {
-    KeBugCheck(CACHE_MANAGER);
-  }
+    Buffer = ExAllocatePool(NonPagedPool, CI_CACHESEG_MAPPING_REGION_SIZE / (PAGE_SIZE * 8));
+    if (!Buffer)
+    {
+        KeBugCheck(CACHE_MANAGER);
+    }
 
-  RtlInitializeBitMap(&CiCacheSegMappingRegionAllocMap, Buffer, CI_CACHESEG_MAPPING_REGION_SIZE / PAGE_SIZE);
-  RtlClearAllBits(&CiCacheSegMappingRegionAllocMap);
+    RtlInitializeBitMap(&CiCacheSegMappingRegionAllocMap, Buffer, CI_CACHESEG_MAPPING_REGION_SIZE / PAGE_SIZE);
+    RtlClearAllBits(&CiCacheSegMappingRegionAllocMap);
 
-  KeInitializeSpinLock(&CiCacheSegMappingRegionLock);
+    KeInitializeSpinLock(&CiCacheSegMappingRegionLock);
 #endif
-  InitializeListHead(&CacheSegmentListHead);
-  InitializeListHead(&DirtySegmentListHead);
-  InitializeListHead(&CacheSegmentLRUListHead);
-  InitializeListHead(&ClosedListHead);
-  KeInitializeGuardedMutex(&ViewLock);
-  ExInitializeNPagedLookasideList (&iBcbLookasideList,
-                                  NULL,
-                                  NULL,
-                                  0,
-                                  sizeof(INTERNAL_BCB),
-                                  TAG_IBCB,
-                                  20);
-  ExInitializeNPagedLookasideList (&BcbLookasideList,
-                                  NULL,
-                                  NULL,
-                                  0,
-                                  sizeof(BCB),
-                                  TAG_BCB,
-                                  20);
-  ExInitializeNPagedLookasideList (&CacheSegLookasideList,
-                                  NULL,
-                                  NULL,
-                                  0,
-                                  sizeof(CACHE_SEGMENT),
-                                  TAG_CSEG,
-                                  20);
-
-  MmInitializeMemoryConsumer(MC_CACHE, CcRosTrimCache);
-
-  CcInitCacheZeroPage();
+    InitializeListHead(&CacheSegmentListHead);
+    InitializeListHead(&DirtySegmentListHead);
+    InitializeListHead(&CacheSegmentLRUListHead);
+    InitializeListHead(&ClosedListHead);
+    KeInitializeGuardedMutex(&ViewLock);
+    ExInitializeNPagedLookasideList (&iBcbLookasideList,
+                                     NULL,
+                                     NULL,
+                                     0,
+                                     sizeof(INTERNAL_BCB),
+                                     TAG_IBCB,
+                                     20);
+    ExInitializeNPagedLookasideList (&BcbLookasideList,
+                                     NULL,
+                                     NULL,
+                                     0,
+                                     sizeof(BCB),
+                                     TAG_BCB,
+                                     20);
+    ExInitializeNPagedLookasideList (&CacheSegLookasideList,
+                                     NULL,
+                                     NULL,
+                                     0,
+                                     sizeof(CACHE_SEGMENT),
+                                     TAG_CSEG,
+                                     20);
+
+    MmInitializeMemoryConsumer(MC_CACHE, CcRosTrimCache);
+
+    CcInitCacheZeroPage();
 
 }