ntoskrnl/cache/fssup.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel
   4  * FILE:            ntoskrnl/cache/fssup.c
   5  * PURPOSE:         Logging and configuration routines
   6  * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
   7  *                  Art Yerkes
   8  */
   9
  10 /* INCLUDES *******************************************************************/
  11
  12 #include <ntoskrnl.h>
  13 #include "newcc.h"
  14 #include "section/newmm.h"
  15 #define NDEBUG
  16 #include <debug.h>
  17
  18 /* GLOBALS ********************************************************************/
  19
  20 PFSN_PREFETCHER_GLOBALS CcPfGlobals;
  21 extern LONG CcOutstandingDeletes;
  22 extern KEVENT CcpLazyWriteEvent;
  23 extern KEVENT CcFinalizeEvent;
  24 extern VOID NTAPI CcpUnmapThread(PVOID Unused);
  25 extern VOID NTAPI CcpLazyWriteThread(PVOID Unused);
  26 HANDLE CcUnmapThreadHandle, CcLazyWriteThreadHandle;
  27 CLIENT_ID CcUnmapThreadId, CcLazyWriteThreadId;
  28 FAST_MUTEX GlobalPageOperation;
  29
  30 /*
  31
  32 A note about private cache maps.
  33
  34 CcInitializeCacheMap and CcUninitializeCacheMap are not meant to be paired,
  35 although they can work that way.
  36
  37 The actual operation I've gleaned from reading both jan kratchovil's writing
  38 and real filesystems is this:
  39
  40 CcInitializeCacheMap means:
  41
  42 Make the indicated FILE_OBJECT have a private cache map if it doesn't already
  43 and make it have a shared cache map if it doesn't already.
  44
  45 CcUninitializeCacheMap means:
  46
  47 Take away the private cache map from this FILE_OBJECT.  If it's the last
  48 private cache map corresponding to a specific shared cache map (the one that
  49 was present in the FILE_OBJECT when it was created), then delete that too,
  50 flusing all cached information.
  51
  52 Using these simple semantics, filesystems can do all the things they actually
  53 do:
  54
  55 - Copy out the shared cache map pointer from a newly initialized file object
  56 and store it in the fcb cache.
  57 - Copy it back into any file object and call CcInitializeCacheMap to make
  58 that file object be associated with the caching of all the other siblings.
  59 - Call CcUninitializeCacheMap on a FILE_OBJECT many times, but have only the
  60 first one count for each specific FILE_OBJECT.
  61 - Have the actual last call to CcUninitializeCacheMap (that is, the one that
  62 causes zero private cache maps to be associated with a shared cache map) to
  63 delete the cache map and flush.
  64
  65 So private cache map here is a light weight structure that just remembers
  66 what shared cache map it associates with.
  67
  68  */
  69 typedef struct _NOCC_PRIVATE_CACHE_MAP
  70 {
  71     LIST_ENTRY ListEntry;
  72     PFILE_OBJECT FileObject;
  73     PNOCC_CACHE_MAP Map;
  74 } NOCC_PRIVATE_CACHE_MAP, *PNOCC_PRIVATE_CACHE_MAP;
  75
  76 LIST_ENTRY CcpAllSharedCacheMaps;
  77
  78 /* FUNCTIONS ******************************************************************/
  79
  80 BOOLEAN
  81 NTAPI
  82 CcInitializeCacheManager(VOID)
  83 {
  84     int i;
  85
  86     DPRINT("Initialize\n");
  87     for (i = 0; i < CACHE_NUM_SECTIONS; i++)
  88     {
  89         KeInitializeEvent(&CcCacheSections[i].ExclusiveWait,
  90                           SynchronizationEvent,
  91                           FALSE);
  92
  93         InitializeListHead(&CcCacheSections[i].ThisFileList);
  94     }
  95
  96     InitializeListHead(&CcpAllSharedCacheMaps);
  97
  98     KeInitializeEvent(&CcDeleteEvent, SynchronizationEvent, FALSE);
  99     KeInitializeEvent(&CcFinalizeEvent, SynchronizationEvent, FALSE);
 100     KeInitializeEvent(&CcpLazyWriteEvent, SynchronizationEvent, FALSE);
 101
 102     CcCacheBitmap->Buffer = ((PULONG)&CcCacheBitmap[1]);
 103     CcCacheBitmap->SizeOfBitMap = ROUND_UP(CACHE_NUM_SECTIONS, 32);
 104     DPRINT1("Cache has %d entries\n", CcCacheBitmap->SizeOfBitMap);
 105     ExInitializeFastMutex(&CcMutex);
 106
 107     return TRUE;
 108 }
 109
 110 VOID
 111 NTAPI
 112 CcPfInitializePrefetcher(VOID)
 113 {
 114     /* Notify debugger */
 115     DbgPrintEx(DPFLTR_PREFETCHER_ID,
 116                DPFLTR_TRACE_LEVEL,
 117                "CCPF: InitializePrefetecher()\n");
 118
 119     /* Setup the Prefetcher Data */
 120     InitializeListHead(&CcPfGlobals.ActiveTraces);
 121     InitializeListHead(&CcPfGlobals.CompletedTraces);
 122     ExInitializeFastMutex(&CcPfGlobals.CompletedTracesLock);
 123
 124     /* FIXME: Setup the rest of the prefetecher */
 125 }
 126
 127 BOOLEAN
 128 NTAPI
 129 CcpAcquireFileLock(PNOCC_CACHE_MAP Map)
 130 {
 131     DPRINT("Calling AcquireForLazyWrite: %x\n", Map->LazyContext);
 132     return Map->Callbacks.AcquireForLazyWrite(Map->LazyContext, TRUE);
 133 }
 134
 135 VOID
 136 NTAPI
 137 CcpReleaseFileLock(PNOCC_CACHE_MAP Map)
 138 {
 139     DPRINT("Releasing Lazy Write %x\n", Map->LazyContext);
 140     Map->Callbacks.ReleaseFromLazyWrite(Map->LazyContext);
 141 }
 142
 143 /*
 144
 145 Cc functions are required to treat alternate streams of a file as the same
 146 for the purpose of caching, meaning that we must be able to find the shared
 147 cache map associated with the ``real'' stream associated with a stream file
 148 object, if one exists.  We do that by identifying a private cache map in
 149 our gamut that has the same volume, device and fscontext as the stream file
 150 object we're holding.  It's heavy but it does work.  This can probably be
 151 improved, although there doesn't seem to be any real association between
 152 a stream file object and a sibling file object in the file object struct
 153 itself.
 154
 155  */
 156
 157 /* Must have CcpLock() */
 158 PFILE_OBJECT CcpFindOtherStreamFileObject(PFILE_OBJECT FileObject)
 159 {
 160     PLIST_ENTRY Entry, Private;
 161     for (Entry = CcpAllSharedCacheMaps.Flink;
 162          Entry != &CcpAllSharedCacheMaps;
 163          Entry = Entry->Flink)
 164     {
 165         /* 'Identical' test for other stream file object */
 166         PNOCC_CACHE_MAP Map = CONTAINING_RECORD(Entry, NOCC_CACHE_MAP, Entry);
 167         for (Private = Map->PrivateCacheMaps.Flink;
 168              Private != &Map->PrivateCacheMaps;
 169              Private = Private->Flink)
 170         {
 171             PNOCC_PRIVATE_CACHE_MAP PrivateMap = CONTAINING_RECORD(Private,
 172                                                                    NOCC_PRIVATE_CACHE_MAP,
 173                                                                    ListEntry);
 174
 175             if (PrivateMap->FileObject->Flags & FO_STREAM_FILE &&
 176                 PrivateMap->FileObject->DeviceObject == FileObject->DeviceObject &&
 177                 PrivateMap->FileObject->Vpb == FileObject->Vpb &&
 178                 PrivateMap->FileObject->FsContext == FileObject->FsContext &&
 179                 PrivateMap->FileObject->FsContext2 == FileObject->FsContext2 &&
 180                 1)
 181             {
 182                 return PrivateMap->FileObject;
 183             }
 184         }
 185     }
 186     return 0;
 187 }
 188
 189 /* Thanks: http://windowsitpro.com/Windows/Articles/ArticleID/3864/pg/2/2.html */
 190
 191 VOID
 192 NTAPI
 193 CcInitializeCacheMap(IN PFILE_OBJECT FileObject,
 194                      IN PCC_FILE_SIZES FileSizes,
 195                      IN BOOLEAN PinAccess,
 196                      IN PCACHE_MANAGER_CALLBACKS Callbacks,
 197                      IN PVOID LazyWriteContext)
 198 {
 199     PNOCC_CACHE_MAP Map = FileObject->SectionObjectPointer->SharedCacheMap;
 200     PNOCC_PRIVATE_CACHE_MAP PrivateCacheMap = FileObject->PrivateCacheMap;
 201
 202     CcpLock();
 203     /* We don't have a shared cache map.  First find out if we have a sibling
 204        stream file object we can take it from. */
 205     if (!Map && FileObject->Flags & FO_STREAM_FILE)
 206     {
 207         PFILE_OBJECT IdenticalStreamFileObject = CcpFindOtherStreamFileObject(FileObject);
 208         if (IdenticalStreamFileObject)
 209             Map = IdenticalStreamFileObject->SectionObjectPointer->SharedCacheMap;
 210         if (Map)
 211         {
 212             DPRINT1("Linking SFO %x to previous SFO %x through cache map %x #\n",
 213                     FileObject,
 214                     IdenticalStreamFileObject,
 215                     Map);
 216         }
 217     }
 218     /* We still don't have a shared cache map.  We need to create one. */
 219     if (!Map)
 220     {
 221         DPRINT("Initializing file object for (%p) %wZ\n",
 222                FileObject,
 223                &FileObject->FileName);
 224
 225         Map = ExAllocatePool(NonPagedPool, sizeof(NOCC_CACHE_MAP));
 226         FileObject->SectionObjectPointer->SharedCacheMap = Map;
 227         Map->FileSizes = *FileSizes;
 228         Map->LazyContext = LazyWriteContext;
 229         Map->ReadAheadGranularity = PAGE_SIZE;
 230         RtlCopyMemory(&Map->Callbacks, Callbacks, sizeof(*Callbacks));
 231
 232         /* For now ... */
 233         DPRINT("FileSizes->ValidDataLength %I64x\n",
 234                FileSizes->ValidDataLength.QuadPart);
 235
 236         InitializeListHead(&Map->AssociatedBcb);
 237         InitializeListHead(&Map->PrivateCacheMaps);
 238         InsertTailList(&CcpAllSharedCacheMaps, &Map->Entry);
 239         DPRINT("New Map %p\n", Map);
 240     }
 241     /* We don't have a private cache map.  Link it with the shared cache map
 242        to serve as a held reference. When the list in the shared cache map
 243        is empty, we know we can delete it. */
 244     if (!PrivateCacheMap)
 245     {
 246         PrivateCacheMap = ExAllocatePool(NonPagedPool,
 247                                          sizeof(*PrivateCacheMap));
 248
 249         FileObject->PrivateCacheMap = PrivateCacheMap;
 250         PrivateCacheMap->FileObject = FileObject;
 251         ObReferenceObject(PrivateCacheMap->FileObject);
 252     }
 253
 254     PrivateCacheMap->Map = Map;
 255     InsertTailList(&Map->PrivateCacheMaps, &PrivateCacheMap->ListEntry);
 256
 257     CcpUnlock();
 258 }
 259
 260 /*
 261
 262 This function is used by NewCC's MM to determine whether any section objects
 263 for a given file are not cache sections.  If that's true, we're not allowed
 264 to resize the file, although nothing actually prevents us from doing ;-)
 265
 266  */
 267
 268 ULONG
 269 NTAPI
 270 CcpCountCacheSections(IN PNOCC_CACHE_MAP Map)
 271 {
 272     PLIST_ENTRY Entry;
 273     ULONG Count;
 274
 275     for (Count = 0, Entry = Map->AssociatedBcb.Flink;
 276          Entry != &Map->AssociatedBcb;
 277          Entry = Entry->Flink, Count++);
 278
 279     return Count;
 280 }
 281
 282 BOOLEAN
 283 NTAPI
 284 CcUninitializeCacheMap(IN PFILE_OBJECT FileObject,
 285                        IN OPTIONAL PLARGE_INTEGER TruncateSize,
 286                        IN OPTIONAL PCACHE_UNINITIALIZE_EVENT UninitializeEvent)
 287 {
 288     BOOLEAN LastMap = FALSE;
 289     PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
 290     PNOCC_PRIVATE_CACHE_MAP PrivateCacheMap = FileObject->PrivateCacheMap;
 291
 292     DPRINT("Uninitializing file object for %wZ SectionObjectPointer %x\n",
 293            &FileObject->FileName,
 294            FileObject->SectionObjectPointer);
 295
 296     ASSERT(UninitializeEvent == NULL);
 297
 298     /* It may not be strictly necessary to flush here, but we do just for
 299        kicks. */
 300     if (Map)
 301         CcpFlushCache(Map, NULL, 0, NULL, FALSE);
 302
 303     CcpLock();
 304     /* We have a private cache map, so we've been initialized and haven't been
 305      * uninitialized. */
 306     if (PrivateCacheMap)
 307     {
 308         ASSERT(!Map || Map == PrivateCacheMap->Map);
 309         ASSERT(PrivateCacheMap->FileObject == FileObject);
 310
 311         RemoveEntryList(&PrivateCacheMap->ListEntry);
 312         /* That was the last private cache map.  It's time to delete all
 313            cache stripes and all aspects of caching on the file. */
 314         if (IsListEmpty(&PrivateCacheMap->Map->PrivateCacheMaps))
 315         {
 316             /* Get rid of all the cache stripes. */
 317             while (!IsListEmpty(&PrivateCacheMap->Map->AssociatedBcb))
 318             {
 319                 PNOCC_BCB Bcb = CONTAINING_RECORD(PrivateCacheMap->Map->AssociatedBcb.Flink,
 320                                                   NOCC_BCB,
 321                                                   ThisFileList);
 322
 323                 DPRINT("Evicting cache stripe #%x\n", Bcb - CcCacheSections);
 324                 Bcb->RefCount = 1;
 325                 CcpDereferenceCache(Bcb - CcCacheSections, TRUE);
 326             }
 327             RemoveEntryList(&PrivateCacheMap->Map->Entry);
 328             ExFreePool(PrivateCacheMap->Map);
 329             FileObject->SectionObjectPointer->SharedCacheMap = NULL;
 330             LastMap = TRUE;
 331         }
 332         ObDereferenceObject(PrivateCacheMap->FileObject);
 333         FileObject->PrivateCacheMap = NULL;
 334         ExFreePool(PrivateCacheMap);
 335     }
 336     CcpUnlock();
 337
 338     DPRINT("Uninit complete\n");
 339
 340     /* The return from CcUninitializeCacheMap means that 'caching was stopped'. */
 341     return LastMap;
 342 }
 343
 344 /*
 345
 346 CcSetFileSizes is used to tell the cache manager that the file changed
 347 size.  In our case, we use the internal Mm method MmExtendCacheSection
 348 to notify Mm that our section potentially changed size, which may mean
 349 truncating off data.
 350
 351  */
 352 VOID
 353 NTAPI
 354 CcSetFileSizes(IN PFILE_OBJECT FileObject,
 355                IN PCC_FILE_SIZES FileSizes)
 356 {
 357     PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
 358     PNOCC_BCB Bcb;
 359
 360     if (!Map) return;
 361     Map->FileSizes = *FileSizes;
 362     Bcb = Map->AssociatedBcb.Flink == &Map->AssociatedBcb ?
 363         NULL : CONTAINING_RECORD(Map->AssociatedBcb.Flink, NOCC_BCB, ThisFileList);
 364     if (!Bcb) return;
 365     MmExtendCacheSection(Bcb->SectionObject, &FileSizes->FileSize, FALSE);
 366     DPRINT("FileSizes->FileSize %x\n", FileSizes->FileSize.LowPart);
 367     DPRINT("FileSizes->AllocationSize %x\n", FileSizes->AllocationSize.LowPart);
 368     DPRINT("FileSizes->ValidDataLength %x\n", FileSizes->ValidDataLength.LowPart);
 369 }
 370
 371 BOOLEAN
 372 NTAPI
 373 CcGetFileSizes(IN PFILE_OBJECT FileObject,
 374                IN PCC_FILE_SIZES FileSizes)
 375 {
 376     PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
 377     if (!Map) return FALSE;
 378     *FileSizes = Map->FileSizes;
 379     return TRUE;
 380 }
 381
 382 BOOLEAN
 383 NTAPI
 384 CcPurgeCacheSection(IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
 385                     IN OPTIONAL PLARGE_INTEGER FileOffset,
 386                     IN ULONG Length,
 387                     IN BOOLEAN UninitializeCacheMaps)
 388 {
 389     PNOCC_CACHE_MAP Map = (PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap;
 390     if (!Map) return TRUE;
 391     CcpFlushCache(Map, NULL, 0, NULL, TRUE);
 392     return TRUE;
 393 }
 394
 395 VOID
 396 NTAPI
 397 CcSetDirtyPageThreshold(IN PFILE_OBJECT FileObject,
 398                         IN ULONG DirtyPageThreshold)
 399 {
 400     UNIMPLEMENTED_DBGBREAK();
 401 }
 402
 403 /*
 404
 405 This could be implemented much more intelligently by mapping instances
 406 of a CoW zero page into the affected regions.  We just RtlZeroMemory
 407 for now.
 408
 409 */
 410 BOOLEAN
 411 NTAPI
 412 CcZeroData(IN PFILE_OBJECT FileObject,
 413            IN PLARGE_INTEGER StartOffset,
 414            IN PLARGE_INTEGER EndOffset,
 415            IN BOOLEAN Wait)
 416 {
 417     PNOCC_BCB Bcb = NULL;
 418     PLIST_ENTRY ListEntry = NULL;
 419     LARGE_INTEGER LowerBound = *StartOffset;
 420     LARGE_INTEGER UpperBound = *EndOffset;
 421     LARGE_INTEGER Target, End;
 422     PVOID PinnedBcb, PinnedBuffer;
 423     PNOCC_CACHE_MAP Map = FileObject->SectionObjectPointer->SharedCacheMap;
 424
 425     DPRINT("S %I64x E %I64x\n",
 426            StartOffset->QuadPart,
 427            EndOffset->QuadPart);
 428
 429     if (!Map)
 430     {
 431         NTSTATUS Status;
 432         IO_STATUS_BLOCK IOSB;
 433         PCHAR ZeroBuf = ExAllocatePool(PagedPool, PAGE_SIZE);
 434         ULONG ToWrite;
 435
 436         if (!ZeroBuf) RtlRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
 437         DPRINT1("RtlZeroMemory(%x,%x)\n", ZeroBuf, PAGE_SIZE);
 438         RtlZeroMemory(ZeroBuf, PAGE_SIZE);
 439
 440         Target.QuadPart = PAGE_ROUND_DOWN(LowerBound.QuadPart);
 441         End.QuadPart = PAGE_ROUND_UP(UpperBound.QuadPart);
 442
 443         // Handle leading page
 444         if (LowerBound.QuadPart != Target.QuadPart)
 445         {
 446             ToWrite = MIN(UpperBound.QuadPart - LowerBound.QuadPart,
 447                           (PAGE_SIZE - LowerBound.QuadPart) & (PAGE_SIZE - 1));
 448
 449             DPRINT("Zero last half %I64x %lx\n",
 450                    Target.QuadPart,
 451                    ToWrite);
 452
 453             Status = MiSimpleRead(FileObject,
 454                                   &Target,
 455                                   ZeroBuf,
 456                                   PAGE_SIZE,
 457                                   TRUE,
 458                                   &IOSB);
 459
 460             if (!NT_SUCCESS(Status))
 461             {
 462                 ExFreePool(ZeroBuf);
 463                 RtlRaiseStatus(Status);
 464             }
 465
 466             DPRINT1("RtlZeroMemory(%p, %lx)\n",
 467                     ZeroBuf + LowerBound.QuadPart - Target.QuadPart,
 468                     ToWrite);
 469
 470             RtlZeroMemory(ZeroBuf + LowerBound.QuadPart - Target.QuadPart,
 471                           ToWrite);
 472
 473             Status = MiSimpleWrite(FileObject,
 474                                    &Target,
 475                                    ZeroBuf,
 476                                    MIN(PAGE_SIZE,
 477                                        UpperBound.QuadPart-Target.QuadPart),
 478                                    &IOSB);
 479
 480             if (!NT_SUCCESS(Status))
 481             {
 482                 ExFreePool(ZeroBuf);
 483                 RtlRaiseStatus(Status);
 484             }
 485             Target.QuadPart += PAGE_SIZE;
 486         }
 487
 488         DPRINT1("RtlZeroMemory(%x,%x)\n", ZeroBuf, PAGE_SIZE);
 489         RtlZeroMemory(ZeroBuf, PAGE_SIZE);
 490
 491         while (UpperBound.QuadPart - Target.QuadPart > PAGE_SIZE)
 492         {
 493             DPRINT("Zero full page %I64x\n",
 494                    Target.QuadPart);
 495
 496             Status = MiSimpleWrite(FileObject,
 497                                    &Target,
 498                                    ZeroBuf,
 499                                    PAGE_SIZE,
 500                                    &IOSB);
 501
 502             if (!NT_SUCCESS(Status))
 503             {
 504                 ExFreePool(ZeroBuf);
 505                 RtlRaiseStatus(Status);
 506             }
 507             Target.QuadPart += PAGE_SIZE;
 508         }
 509
 510         if (UpperBound.QuadPart > Target.QuadPart)
 511         {
 512             ToWrite = UpperBound.QuadPart - Target.QuadPart;
 513             DPRINT("Zero first half %I64x %lx\n",
 514                    Target.QuadPart,
 515                    ToWrite);
 516
 517             Status = MiSimpleRead(FileObject,
 518                                   &Target,
 519                                   ZeroBuf,
 520                                   PAGE_SIZE,
 521                                   TRUE,
 522                                   &IOSB);
 523
 524             if (!NT_SUCCESS(Status))
 525             {
 526                 ExFreePool(ZeroBuf);
 527                 RtlRaiseStatus(Status);
 528             }
 529             DPRINT1("RtlZeroMemory(%x,%x)\n", ZeroBuf, ToWrite);
 530             RtlZeroMemory(ZeroBuf, ToWrite);
 531             Status = MiSimpleWrite(FileObject,
 532                                    &Target,
 533                                    ZeroBuf,
 534                                    MIN(PAGE_SIZE,
 535                                        UpperBound.QuadPart-Target.QuadPart),
 536                                    &IOSB);
 537             if (!NT_SUCCESS(Status))
 538             {
 539                 ExFreePool(ZeroBuf);
 540                 RtlRaiseStatus(Status);
 541             }
 542             Target.QuadPart += PAGE_SIZE;
 543         }
 544
 545         ExFreePool(ZeroBuf);
 546         return TRUE;
 547     }
 548
 549     CcpLock();
 550     ListEntry = Map->AssociatedBcb.Flink;
 551
 552     while (ListEntry != &Map->AssociatedBcb)
 553     {
 554         Bcb = CONTAINING_RECORD(ListEntry, NOCC_BCB, ThisFileList);
 555         CcpReferenceCache(Bcb - CcCacheSections);
 556
 557         if (Bcb->FileOffset.QuadPart + Bcb->Length >= LowerBound.QuadPart &&
 558             Bcb->FileOffset.QuadPart < UpperBound.QuadPart)
 559         {
 560             DPRINT("Bcb #%x (@%I64x)\n",
 561                    Bcb - CcCacheSections,
 562                    Bcb->FileOffset.QuadPart);
 563
 564             Target.QuadPart = MAX(Bcb->FileOffset.QuadPart,
 565                                   LowerBound.QuadPart);
 566
 567             End.QuadPart = MIN(Map->FileSizes.ValidDataLength.QuadPart,
 568                                UpperBound.QuadPart);
 569
 570             End.QuadPart = MIN(End.QuadPart,
 571                                Bcb->FileOffset.QuadPart + Bcb->Length);
 572
 573             CcpUnlock();
 574
 575             if (!CcPreparePinWrite(FileObject,
 576                                    &Target,
 577                                    End.QuadPart - Target.QuadPart,
 578                                    TRUE,
 579                                    Wait,
 580                                    &PinnedBcb,
 581                                    &PinnedBuffer))
 582             {
 583                 return FALSE;
 584             }
 585
 586             ASSERT(PinnedBcb == Bcb);
 587
 588             CcpLock();
 589             ListEntry = ListEntry->Flink;
 590             /* Return from pin state */
 591             CcpUnpinData(PinnedBcb, TRUE);
 592         }
 593
 594         CcpUnpinData(Bcb, TRUE);
 595     }
 596
 597     CcpUnlock();
 598
 599     return TRUE;
 600 }
 601
 602 PFILE_OBJECT
 603 NTAPI
 604 CcGetFileObjectFromSectionPtrs(IN PSECTION_OBJECT_POINTERS SectionObjectPointer)
 605 {
 606     PFILE_OBJECT Result = NULL;
 607     PNOCC_CACHE_MAP Map = SectionObjectPointer->SharedCacheMap;
 608     CcpLock();
 609     if (!IsListEmpty(&Map->AssociatedBcb))
 610     {
 611         PNOCC_BCB Bcb = CONTAINING_RECORD(Map->AssociatedBcb.Flink,
 612                                           NOCC_BCB,
 613                                           ThisFileList);
 614
 615         Result = MmGetFileObjectForSection((PROS_SECTION_OBJECT)Bcb->SectionObject);
 616     }
 617     CcpUnlock();
 618     return Result;
 619 }
 620
 621 PFILE_OBJECT
 622 NTAPI
 623 CcGetFileObjectFromBcb(PVOID Bcb)
 624 {
 625     PNOCC_BCB RealBcb = (PNOCC_BCB)Bcb;
 626     DPRINT("BCB #%x\n", RealBcb - CcCacheSections);
 627     return MmGetFileObjectForSection((PROS_SECTION_OBJECT)RealBcb->SectionObject);
 628 }
 629
 630 /* EOF */