ntoskrnl/cc/fs.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS kernel
   4  * FILE:            ntoskrnl/cc/fs.c
   5  * PURPOSE:         Implements cache managers functions useful for File Systems
   6  *
   7  * PROGRAMMERS:     Alex Ionescu
   8  */
   9
  10 /* INCLUDES ******************************************************************/
  11
  12 #include <ntoskrnl.h>
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16 /* GLOBALS   *****************************************************************/
  17
  18 extern KGUARDED_MUTEX ViewLock;
  19
  20 NTSTATUS CcRosInternalFreeVacb(PROS_VACB Vacb);
  21
  22 /* FUNCTIONS *****************************************************************/
  23
  24 /*
  25  * @unimplemented
  26  */
  27 LARGE_INTEGER
  28 NTAPI
  29 CcGetDirtyPages (
  30     IN PVOID LogHandle,
  31     IN PDIRTY_PAGE_ROUTINE DirtyPageRoutine,
  32     IN PVOID Context1,
  33     IN PVOID Context2)
  34 {
  35     LARGE_INTEGER i;
  36
  37     CCTRACE(CC_API_DEBUG, "LogHandle=%p DirtyPageRoutine=%p Context1=%p Context2=%p\n",
  38         LogHandle, DirtyPageRoutine, Context1, Context2);
  39
  40     UNIMPLEMENTED;
  41     i.QuadPart = 0;
  42     return i;
  43 }
  44
  45 /*
  46  * @implemented
  47  */
  48 PFILE_OBJECT
  49 NTAPI
  50 CcGetFileObjectFromBcb (
  51     IN PVOID Bcb)
  52 {
  53     PINTERNAL_BCB iBcb = (PINTERNAL_BCB)Bcb;
  54
  55     CCTRACE(CC_API_DEBUG, "Bcb=%p\n", Bcb);
  56
  57     return iBcb->Vacb->SharedCacheMap->FileObject;
  58 }
  59
  60 /*
  61  * @unimplemented
  62  */
  63 LARGE_INTEGER
  64 NTAPI
  65 CcGetLsnForFileObject (
  66     IN PFILE_OBJECT FileObject,
  67     OUT PLARGE_INTEGER OldestLsn OPTIONAL)
  68 {
  69     LARGE_INTEGER i;
  70
  71     CCTRACE(CC_API_DEBUG, "FileObject=%p\n", FileObject);
  72
  73     UNIMPLEMENTED;
  74     i.QuadPart = 0;
  75     return i;
  76 }
  77
  78 /*
  79  * @unimplemented
  80  */
  81 VOID
  82 NTAPI
  83 CcInitializeCacheMap (
  84     IN PFILE_OBJECT FileObject,
  85     IN PCC_FILE_SIZES FileSizes,
  86     IN BOOLEAN PinAccess,
  87     IN PCACHE_MANAGER_CALLBACKS CallBacks,
  88     IN PVOID LazyWriterContext)
  89 {
  90     NTSTATUS Status;
  91
  92     ASSERT(FileObject);
  93     ASSERT(FileSizes);
  94
  95     CCTRACE(CC_API_DEBUG, "FileObject=%p FileSizes=%p PinAccess=%d CallBacks=%p LazyWriterContext=%p\n",
  96         FileObject, FileSizes, PinAccess, CallBacks, LazyWriterContext);
  97
  98     /* Call old ROS cache init function */
  99     Status = CcRosInitializeFileCache(FileObject,
 100                                       FileSizes,
 101                                       PinAccess,
 102                                       CallBacks,
 103                                       LazyWriterContext);
 104     if (!NT_SUCCESS(Status))
 105         ExRaiseStatus(Status);
 106 }
 107
 108 /*
 109  * @implemented
 110  */
 111 BOOLEAN
 112 NTAPI
 113 CcIsThereDirtyData (
 114     IN PVPB Vpb)
 115 {
 116     PROS_VACB Vacb;
 117     PLIST_ENTRY Entry;
 118     /* Assume no dirty data */
 119     BOOLEAN Dirty = FALSE;
 120
 121     CCTRACE(CC_API_DEBUG, "Vpb=%p\n", Vpb);
 122
 123     KeAcquireGuardedMutex(&ViewLock);
 124
 125     /* Browse dirty VACBs */
 126     for (Entry = DirtyVacbListHead.Flink; Entry != &DirtyVacbListHead; Entry = Entry->Flink)
 127     {
 128         Vacb = CONTAINING_RECORD(Entry, ROS_VACB, DirtyVacbListEntry);
 129         /* Look for these associated with our volume */
 130         if (Vacb->SharedCacheMap->FileObject->Vpb != Vpb)
 131         {
 132             continue;
 133         }
 134
 135         /* From now on, we are associated with our VPB */
 136
 137         /* Temporary files are not counted as dirty */
 138         if (BooleanFlagOn(Vacb->SharedCacheMap->FileObject->Flags, FO_TEMPORARY_FILE))
 139         {
 140             continue;
 141         }
 142
 143         /* A single dirty VACB is enough to have dirty data */
 144         if (Vacb->Dirty)
 145         {
 146             Dirty = TRUE;
 147             break;
 148         }
 149     }
 150
 151     KeReleaseGuardedMutex(&ViewLock);
 152
 153     return Dirty;
 154 }
 155
 156 /*
 157  * @unimplemented
 158  */
 159 BOOLEAN
 160 NTAPI
 161 CcPurgeCacheSection (
 162     IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
 163     IN PLARGE_INTEGER FileOffset OPTIONAL,
 164     IN ULONG Length,
 165     IN BOOLEAN UninitializeCacheMaps)
 166 {
 167     PROS_SHARED_CACHE_MAP SharedCacheMap;
 168     LONGLONG StartOffset;
 169     LONGLONG EndOffset;
 170     LIST_ENTRY FreeList;
 171     KIRQL OldIrql;
 172     PLIST_ENTRY ListEntry;
 173     PROS_VACB Vacb;
 174     LONGLONG ViewEnd;
 175     BOOLEAN Success;
 176
 177     CCTRACE(CC_API_DEBUG, "SectionObjectPointer=%p\n FileOffset=%p Length=%lu UninitializeCacheMaps=%d",
 178         SectionObjectPointer, FileOffset, Length, UninitializeCacheMaps);
 179
 180     if (UninitializeCacheMaps)
 181     {
 182         DPRINT1("FIXME: CcPurgeCacheSection not uninitializing private cache maps\n");
 183     }
 184
 185     SharedCacheMap = SectionObjectPointer->SharedCacheMap;
 186     if (!SharedCacheMap)
 187         return FALSE;
 188
 189     StartOffset = FileOffset != NULL ? FileOffset->QuadPart : 0;
 190     if (Length == 0 || FileOffset == NULL)
 191     {
 192         EndOffset = MAXLONGLONG;
 193     }
 194     else
 195     {
 196         EndOffset = StartOffset + Length;
 197         ASSERT(EndOffset > StartOffset);
 198     }
 199
 200     InitializeListHead(&FreeList);
 201
 202     /* Assume success */
 203     Success = TRUE;
 204
 205     KeAcquireGuardedMutex(&ViewLock);
 206     KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &OldIrql);
 207     ListEntry = SharedCacheMap->CacheMapVacbListHead.Flink;
 208     while (ListEntry != &SharedCacheMap->CacheMapVacbListHead)
 209     {
 210         Vacb = CONTAINING_RECORD(ListEntry, ROS_VACB, CacheMapVacbListEntry);
 211         ListEntry = ListEntry->Flink;
 212
 213         /* Skip VACBs outside the range, or only partially in range */
 214         if (Vacb->FileOffset.QuadPart < StartOffset)
 215         {
 216             continue;
 217         }
 218         ViewEnd = min(Vacb->FileOffset.QuadPart + VACB_MAPPING_GRANULARITY,
 219                       SharedCacheMap->SectionSize.QuadPart);
 220         if (ViewEnd >= EndOffset)
 221         {
 222             break;
 223         }
 224
 225         /* Still in use, it cannot be purged, fail
 226          * Allow one ref: VACB is supposed to be always 1-referenced
 227          */
 228         if ((Vacb->ReferenceCount > 1 && !Vacb->Dirty) ||
 229             (Vacb->ReferenceCount > 2 && Vacb->Dirty))
 230         {
 231             Success = FALSE;
 232             break;
 233         }
 234
 235         /* This VACB is in range, so unlink it and mark for free */
 236         ASSERT(Vacb->ReferenceCount == 1 || Vacb->Dirty);
 237         RemoveEntryList(&Vacb->VacbLruListEntry);
 238         if (Vacb->Dirty)
 239         {
 240             CcRosUnmarkDirtyVacb(Vacb, FALSE);
 241         }
 242         RemoveEntryList(&Vacb->CacheMapVacbListEntry);
 243         InsertHeadList(&FreeList, &Vacb->CacheMapVacbListEntry);
 244     }
 245     KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, OldIrql);
 246     KeReleaseGuardedMutex(&ViewLock);
 247
 248     while (!IsListEmpty(&FreeList))
 249     {
 250         Vacb = CONTAINING_RECORD(RemoveHeadList(&FreeList),
 251                                  ROS_VACB,
 252                                  CacheMapVacbListEntry);
 253         CcRosVacbDecRefCount(Vacb);
 254         CcRosInternalFreeVacb(Vacb);
 255     }
 256
 257     return Success;
 258 }
 259
 260
 261 /*
 262  * @implemented
 263  */
 264 VOID NTAPI
 265 CcSetFileSizes (
 266     IN PFILE_OBJECT FileObject,
 267     IN PCC_FILE_SIZES FileSizes)
 268 {
 269     KIRQL oldirql;
 270     PROS_SHARED_CACHE_MAP SharedCacheMap;
 271
 272     CCTRACE(CC_API_DEBUG, "FileObject=%p FileSizes=%p\n",
 273         FileObject, FileSizes);
 274
 275     DPRINT("CcSetFileSizes(FileObject 0x%p, FileSizes 0x%p)\n",
 276            FileObject, FileSizes);
 277     DPRINT("AllocationSize %I64d, FileSize %I64d, ValidDataLength %I64d\n",
 278            FileSizes->AllocationSize.QuadPart,
 279            FileSizes->FileSize.QuadPart,
 280            FileSizes->ValidDataLength.QuadPart);
 281
 282     SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
 283
 284     /*
 285      * It is valid to call this function on file objects that weren't
 286      * initialized for caching. In this case it's simple no-op.
 287      */
 288     if (SharedCacheMap == NULL)
 289         return;
 290
 291     if (FileSizes->AllocationSize.QuadPart < SharedCacheMap->SectionSize.QuadPart)
 292     {
 293         CcPurgeCacheSection(FileObject->SectionObjectPointer,
 294                             &FileSizes->AllocationSize,
 295                             0,
 296                             FALSE);
 297     }
 298
 299     KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &oldirql);
 300     SharedCacheMap->SectionSize = FileSizes->AllocationSize;
 301     SharedCacheMap->FileSize = FileSizes->FileSize;
 302     KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, oldirql);
 303 }
 304
 305 /*
 306  * @unimplemented
 307  */
 308 VOID
 309 NTAPI
 310 CcSetLogHandleForFile (
 311     IN PFILE_OBJECT FileObject,
 312     IN PVOID LogHandle,
 313     IN PFLUSH_TO_LSN FlushToLsnRoutine)
 314 {
 315     CCTRACE(CC_API_DEBUG, "FileObject=%p LogHandle=%p FlushToLsnRoutine=%p\n",
 316         FileObject, LogHandle, FlushToLsnRoutine);
 317
 318     UNIMPLEMENTED;
 319 }
 320
 321 /*
 322  * @unimplemented
 323  */
 324 BOOLEAN
 325 NTAPI
 326 CcUninitializeCacheMap (
 327     IN PFILE_OBJECT FileObject,
 328     IN PLARGE_INTEGER TruncateSize OPTIONAL,
 329     IN PCACHE_UNINITIALIZE_EVENT UninitializeCompleteEvent OPTIONAL)
 330 {
 331     NTSTATUS Status;
 332     PROS_SHARED_CACHE_MAP SharedCacheMap;
 333     KIRQL OldIrql;
 334
 335     CCTRACE(CC_API_DEBUG, "FileObject=%p TruncateSize=%p UninitializeCompleteEvent=%p\n",
 336         FileObject, TruncateSize, UninitializeCompleteEvent);
 337
 338     if (TruncateSize != NULL &&
 339         FileObject->SectionObjectPointer->SharedCacheMap != NULL)
 340     {
 341         SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
 342         KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &OldIrql);
 343         if (SharedCacheMap->FileSize.QuadPart > TruncateSize->QuadPart)
 344         {
 345             SharedCacheMap->FileSize = *TruncateSize;
 346         }
 347         KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, OldIrql);
 348         CcPurgeCacheSection(FileObject->SectionObjectPointer,
 349                             TruncateSize,
 350                             0,
 351                             FALSE);
 352     }
 353
 354     Status = CcRosReleaseFileCache(FileObject);
 355     if (UninitializeCompleteEvent)
 356     {
 357         KeSetEvent(&UninitializeCompleteEvent->Event, IO_NO_INCREMENT, FALSE);
 358     }
 359     return NT_SUCCESS(Status);
 360 }
 361
 362 BOOLEAN
 363 NTAPI
 364 CcGetFileSizes (
 365     IN PFILE_OBJECT FileObject,
 366     IN PCC_FILE_SIZES FileSizes)
 367 {
 368     PROS_SHARED_CACHE_MAP SharedCacheMap;
 369
 370     SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
 371
 372     if (!SharedCacheMap)
 373         return FALSE;
 374
 375     FileSizes->AllocationSize = SharedCacheMap->SectionSize;
 376     FileSizes->FileSize = FileSizes->ValidDataLength = SharedCacheMap->FileSize;
 377     return TRUE;
 378 }