ReactOS  0.4.12-dev-396-g37af787
copy.c File Reference
#include <ntoskrnl.h>
#include <debug.h>
Include dependency graph for copy.c:

Go to the source code of this file.

Macros

#define NDEBUG
 
#define MAX_ZERO_LENGTH   (256 * 1024)
 

Typedefs

typedef enum _CC_COPY_OPERATION CC_COPY_OPERATION
 
typedef enum _CC_CAN_WRITE_RETRY CC_CAN_WRITE_RETRY
 

Enumerations

enum  _CC_COPY_OPERATION { CcOperationRead, CcOperationWrite, CcOperationZero }
 
enum  _CC_CAN_WRITE_RETRY { FirstTry = 0, RetryAllowRemote = 253, RetryForceCheckPerFile = 254, RetryMasterLocked = 255 }
 

Functions

VOID NTAPI MiZeroPhysicalPage (IN PFN_NUMBER PageFrameIndex)
 
VOID NTAPI CcInitCacheZeroPage (VOID)
 
NTSTATUS NTAPI CcReadVirtualAddress (PROS_VACB Vacb)
 
NTSTATUS NTAPI CcWriteVirtualAddress (PROS_VACB Vacb)
 
NTSTATUS ReadWriteOrZero (_Inout_ PVOID BaseAddress, _Inout_opt_ PVOID Buffer, _In_ ULONG Length, _In_ CC_COPY_OPERATION Operation)
 
BOOLEAN CcCopyData (_In_ PFILE_OBJECT FileObject, _In_ LONGLONG FileOffset, _Inout_ PVOID Buffer, _In_ LONGLONG Length, _In_ CC_COPY_OPERATION Operation, _In_ BOOLEAN Wait, _Out_ PIO_STATUS_BLOCK IoStatus)
 
VOID CcPostDeferredWrites (VOID)
 
VOID CcPerformReadAhead (IN PFILE_OBJECT FileObject)
 
BOOLEAN NTAPI CcCanIWrite (IN PFILE_OBJECT FileObject, IN ULONG BytesToWrite, IN BOOLEAN Wait, IN BOOLEAN Retrying)
 
BOOLEAN NTAPI CcCopyRead (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus)
 
BOOLEAN NTAPI CcCopyWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN PVOID Buffer)
 
VOID NTAPI CcDeferWrite (IN PFILE_OBJECT FileObject, IN PCC_POST_DEFERRED_WRITE PostRoutine, IN PVOID Context1, IN PVOID Context2, IN ULONG BytesToWrite, IN BOOLEAN Retrying)
 
VOID NTAPI CcFastCopyRead (IN PFILE_OBJECT FileObject, IN ULONG FileOffset, IN ULONG Length, IN ULONG PageCount, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus)
 
VOID NTAPI CcFastCopyWrite (IN PFILE_OBJECT FileObject, IN ULONG FileOffset, IN ULONG Length, IN PVOID Buffer)
 
BOOLEAN NTAPI CcZeroData (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER StartOffset, IN PLARGE_INTEGER EndOffset, IN BOOLEAN Wait)
 

Variables

static PFN_NUMBER CcZeroPage = 0
 
ULONG CcRosTraceLevel = 0
 
ULONG CcFastMdlReadWait
 
ULONG CcFastMdlReadNotPossible
 
ULONG CcFastReadNotPossible
 
ULONG CcFastReadWait
 
ULONG CcFastReadNoWait
 
ULONG CcFastReadResourceMiss
 
ULONG CcDataPages = 0
 
ULONG CcDataFlushes = 0
 

Macro Definition Documentation

◆ MAX_ZERO_LENGTH

#define MAX_ZERO_LENGTH   (256 * 1024)

Definition at line 21 of file copy.c.

◆ NDEBUG

#define NDEBUG

Definition at line 14 of file copy.c.

Typedef Documentation

◆ CC_CAN_WRITE_RETRY

◆ CC_COPY_OPERATION

Enumeration Type Documentation

◆ _CC_CAN_WRITE_RETRY

Enumerator
FirstTry 
RetryAllowRemote 
RetryForceCheckPerFile 
RetryMasterLocked 

Definition at line 30 of file copy.c.

31 {
32  FirstTry = 0,
33  RetryAllowRemote = 253,
35  RetryMasterLocked = 255,
enum _CC_CAN_WRITE_RETRY CC_CAN_WRITE_RETRY
Definition: copy.c:32

◆ _CC_COPY_OPERATION

Enumerator
CcOperationRead 
CcOperationWrite 
CcOperationZero 

Definition at line 23 of file copy.c.

24 {
enum _CC_COPY_OPERATION CC_COPY_OPERATION

Function Documentation

◆ CcCanIWrite()

BOOLEAN NTAPI CcCanIWrite ( IN PFILE_OBJECT  FileObject,
IN ULONG  BytesToWrite,
IN BOOLEAN  Wait,
IN BOOLEAN  Retrying 
)

Definition at line 650 of file copy.c.

655 {
656  KIRQL OldIrql;
657  KEVENT WaitEvent;
658  ULONG Length, Pages;
659  BOOLEAN PerFileDefer;
662  CC_CAN_WRITE_RETRY TryContext;
663  PROS_SHARED_CACHE_MAP SharedCacheMap;
664 
665  CCTRACE(CC_API_DEBUG, "FileObject=%p BytesToWrite=%lu Wait=%d Retrying=%d\n",
666  FileObject, BytesToWrite, Wait, Retrying);
667 
668  /* Write through is always OK */
670  {
671  return TRUE;
672  }
673 
674  TryContext = Retrying;
675  /* Allow remote file if not from posted */
676  if (IoIsFileOriginRemote(FileObject) && TryContext < RetryAllowRemote)
677  {
678  return TRUE;
679  }
680 
681  /* Don't exceed max tolerated size */
683  if (BytesToWrite < MAX_ZERO_LENGTH)
684  {
685  Length = BytesToWrite;
686  }
687 
688  Pages = BYTES_TO_PAGES(Length);
689 
690  /* By default, assume limits per file won't be hit */
691  PerFileDefer = FALSE;
692  Fcb = FileObject->FsContext;
693  /* Do we have to check for limits per file? */
694  if (TryContext >= RetryForceCheckPerFile ||
696  {
697  /* If master is not locked, lock it now */
698  if (TryContext != RetryMasterLocked)
699  {
701  }
702 
703  /* Let's not assume the file is cached... */
704  if (FileObject->SectionObjectPointer != NULL &&
705  FileObject->SectionObjectPointer->SharedCacheMap != NULL)
706  {
707  SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
708  /* Do we have limits per file set? */
709  if (SharedCacheMap->DirtyPageThreshold != 0 &&
710  SharedCacheMap->DirtyPages != 0)
711  {
712  /* Yes, check whether they are blocking */
713  if (Pages + SharedCacheMap->DirtyPages > SharedCacheMap->DirtyPageThreshold)
714  {
715  PerFileDefer = TRUE;
716  }
717  }
718  }
719 
720  /* And don't forget to release master */
721  if (TryContext != RetryMasterLocked)
722  {
724  }
725  }
726 
727  /* So, now allow write if:
728  * - Not the first try or we have no throttling yet
729  * AND:
730  * - We don't exceed threshold!
731  * - We don't exceed what Mm can allow us to use
732  * + If we're above top, that's fine
733  * + If we're above bottom with limited modified pages, that's fine
734  * + Otherwise, throttle!
735  */
736  if ((TryContext != FirstTry || IsListEmpty(&CcDeferredWrites)) &&
740  !PerFileDefer)
741  {
742  return TRUE;
743  }
744 
745  /* If we can wait, we'll start the wait loop for waiting till we can
746  * write for real
747  */
748  if (!Wait)
749  {
750  return FALSE;
751  }
752 
753  /* Otherwise, if there are no deferred writes yet, start the lazy writer */
755  {
756  KIRQL OldIrql;
757 
761  }
762 
763  /* Initialize our wait event */
765 
766  /* And prepare a dummy context */
767  Context.NodeTypeCode = NODE_TYPE_DEFERRED_WRITE;
768  Context.NodeByteSize = sizeof(DEFERRED_WRITE);
769  Context.FileObject = FileObject;
770  Context.BytesToWrite = BytesToWrite;
772  Context.Event = &WaitEvent;
773 
774  /* And queue it */
775  if (Retrying)
776  {
777  /* To the top, if that's a retry */
779  &Context.DeferredWriteLinks,
781  }
782  else
783  {
784  /* To the bottom, if that's a first time */
786  &Context.DeferredWriteLinks,
788  }
789 
790  DPRINT1("Actively deferring write for: %p\n", FileObject);
791  /* Now, we'll loop until our event is set. When it is set, it means that caller
792  * can immediately write, and has to
793  */
794  do
795  {
798 
799  return TRUE;
800 }
#define TRUE
Definition: types.h:120
ULONG CcDirtyPageThreshold
Definition: view.c:59
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
PLIST_ENTRY NTAPI ExInterlockedInsertTailList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:140
PFN_NUMBER MmAvailablePages
Definition: freelist.c:26
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
VOID CcPostDeferredWrites(VOID)
Definition: copy.c:413
UCHAR KIRQL
Definition: env_spec_w32.h:591
PLIST_ENTRY NTAPI ExInterlockedInsertHeadList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:114
BOOLEAN NTAPI IoIsFileOriginRemote(IN PFILE_OBJECT FileObject)
Definition: file.c:3277
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
#define NODE_TYPE_DEFERRED_WRITE
Definition: cc.h:287
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
#define CC_API_DEBUG
Definition: cc.h:11
struct _DEFERRED_WRITE DEFERRED_WRITE
enum _CC_CAN_WRITE_RETRY CC_CAN_WRITE_RETRY
LIST_ENTRY CcDeferredWrites
Definition: view.c:61
VOID FASTCALL KeReleaseQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber, IN KIRQL OldIrql)
Definition: spinlock.c:154
#define CCTRACE(x, fmt,...)
Definition: cc.h:36
MMPFNLIST MmModifiedPageListHead
Definition: pfnlist.c:45
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
#define FSRTL_FLAG_LIMIT_MODIFIED_PAGES
Definition: fsrtltypes.h:47
KSPIN_LOCK CcDeferredWriteSpinLock
Definition: view.c:62
ULONG Flags
Definition: ntfs.h:520
ULONG MmThrottleBottom
Definition: mminit.c:397
#define BYTES_TO_PAGES(Size)
ULONG CcTotalDirtyPages
Definition: view.c:60
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
Definition: copy.c:32
KIRQL FASTCALL KeAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
Definition: spinlock.c:108
ULONG MmThrottleTop
Definition: mminit.c:396
VOID CcScheduleLazyWriteScan(IN BOOLEAN NoDelay)
Definition: lazywrite.c:200
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
PFN_NUMBER Total
Definition: mm.h:371
#define DPRINT1
Definition: precomp.h:8
LARGE_INTEGER CcIdleDelay
Definition: lazywrite.c:46
struct tagContext Context
Definition: acpixf.h:1020
unsigned int ULONG
Definition: retypes.h:1
_In_ PFCB Fcb
Definition: cdprocs.h:151
return STATUS_SUCCESS
Definition: btrfs.c:2725
ULONG DirtyPageThreshold
Definition: cc.h:185
ULONG DirtyPages
Definition: cc.h:179
#define FO_WRITE_THROUGH
Definition: iotypes.h:1735
IN BOOLEAN Wait
Definition: fatprocs.h:1529
#define MAX_ZERO_LENGTH
Definition: copy.c:21

Referenced by CcPostDeferredWrites().

◆ CcCopyData()

BOOLEAN CcCopyData ( _In_ PFILE_OBJECT  FileObject,
_In_ LONGLONG  FileOffset,
_Inout_ PVOID  Buffer,
_In_ LONGLONG  Length,
_In_ CC_COPY_OPERATION  Operation,
_In_ BOOLEAN  Wait,
_Out_ PIO_STATUS_BLOCK  IoStatus 
)

Definition at line 258 of file copy.c.

266 {
268  LONGLONG CurrentOffset;
270  KIRQL OldIrql;
271  PROS_SHARED_CACHE_MAP SharedCacheMap;
272  PLIST_ENTRY ListEntry;
273  PROS_VACB Vacb;
274  ULONG PartialLength;
276  BOOLEAN Valid;
277  PPRIVATE_CACHE_MAP PrivateCacheMap;
278 
279  SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
280  PrivateCacheMap = FileObject->PrivateCacheMap;
281  CurrentOffset = FileOffset;
282  BytesCopied = 0;
283 
284  if (!Wait)
285  {
286  /* test if the requested data is available */
287  KeAcquireSpinLock(&SharedCacheMap->CacheMapLock, &OldIrql);
288  /* FIXME: this loop doesn't take into account areas that don't have
289  * a VACB in the list yet */
290  ListEntry = SharedCacheMap->CacheMapVacbListHead.Flink;
291  while (ListEntry != &SharedCacheMap->CacheMapVacbListHead)
292  {
293  Vacb = CONTAINING_RECORD(ListEntry,
294  ROS_VACB,
295  CacheMapVacbListEntry);
296  ListEntry = ListEntry->Flink;
297  if (!Vacb->Valid &&
300  CurrentOffset, Length))
301  {
302  KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, OldIrql);
303  /* data not available */
304  return FALSE;
305  }
306  if (Vacb->FileOffset.QuadPart >= CurrentOffset + Length)
307  break;
308  }
309  KeReleaseSpinLock(&SharedCacheMap->CacheMapLock, OldIrql);
310  }
311 
312  PartialLength = CurrentOffset % VACB_MAPPING_GRANULARITY;
313  if (PartialLength != 0)
314  {
315  PartialLength = min(Length, VACB_MAPPING_GRANULARITY - PartialLength);
316  Status = CcRosRequestVacb(SharedCacheMap,
317  ROUND_DOWN(CurrentOffset,
319  &BaseAddress,
320  &Valid,
321  &Vacb);
322  if (!NT_SUCCESS(Status))
324  if (!Valid)
325  {
327  if (!NT_SUCCESS(Status))
328  {
329  CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
331  }
332  }
334  Buffer,
335  PartialLength,
336  Operation);
337 
338  CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, Operation != CcOperationRead, FALSE);
339 
340  if (!NT_SUCCESS(Status))
342 
343  Length -= PartialLength;
344  CurrentOffset += PartialLength;
345  BytesCopied += PartialLength;
346 
347  if (Operation != CcOperationZero)
348  Buffer = (PVOID)((ULONG_PTR)Buffer + PartialLength);
349  }
350 
351  while (Length > 0)
352  {
353  ASSERT(CurrentOffset % VACB_MAPPING_GRANULARITY == 0);
354  PartialLength = min(VACB_MAPPING_GRANULARITY, Length);
355  Status = CcRosRequestVacb(SharedCacheMap,
356  CurrentOffset,
357  &BaseAddress,
358  &Valid,
359  &Vacb);
360  if (!NT_SUCCESS(Status))
362  if (!Valid &&
364  PartialLength < VACB_MAPPING_GRANULARITY))
365  {
367  if (!NT_SUCCESS(Status))
368  {
369  CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
371  }
372  }
373  Status = ReadWriteOrZero(BaseAddress, Buffer, PartialLength, Operation);
374 
375  CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, Operation != CcOperationRead, FALSE);
376 
377  if (!NT_SUCCESS(Status))
379 
380  Length -= PartialLength;
381  CurrentOffset += PartialLength;
382  BytesCopied += PartialLength;
383 
384  if (Operation != CcOperationZero)
385  Buffer = (PVOID)((ULONG_PTR)Buffer + PartialLength);
386  }
387 
388  /* If that was a successful sync read operation, let's handle read ahead */
389  if (Operation == CcOperationRead && Length == 0 && Wait)
390  {
391  /* If file isn't random access and next read may get us cross VACB boundary,
392  * schedule next read
393  */
394  if (!BooleanFlagOn(FileObject->Flags, FO_RANDOM_ACCESS) &&
395  (CurrentOffset - 1) / VACB_MAPPING_GRANULARITY != (CurrentOffset + BytesCopied - 1) / VACB_MAPPING_GRANULARITY)
396  {
398  }
399 
400  /* And update read history in private cache map */
401  PrivateCacheMap->FileOffset1.QuadPart = PrivateCacheMap->FileOffset2.QuadPart;
402  PrivateCacheMap->BeyondLastByte1.QuadPart = PrivateCacheMap->BeyondLastByte2.QuadPart;
403  PrivateCacheMap->FileOffset2.QuadPart = FileOffset;
404  PrivateCacheMap->BeyondLastByte2.QuadPart = FileOffset + BytesCopied;
405  }
406 
407  IoStatus->Status = STATUS_SUCCESS;
408  IoStatus->Information = BytesCopied;
409  return TRUE;
410 }
#define TRUE
Definition: types.h:120
Definition: cc.h:202
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN OUT PIO_STATUS_BLOCK IoStatus
Definition: fatprocs.h:2650
LARGE_INTEGER BeyondLastByte2
Definition: cctypes.h:80
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
unsigned char * PUCHAR
Definition: retypes.h:3
LONG NTSTATUS
Definition: precomp.h:26
#define FO_RANDOM_ACCESS
Definition: iotypes.h:1752
#define ExRaiseStatus
Definition: ntoskrnl.h:95
VOID NTAPI CcScheduleReadAhead(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length)
Definition: cachesub.c:92
uint32_t ULONG_PTR
Definition: typedefs.h:63
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define STATUS_INVALID_USER_BUFFER
Definition: udferr_usr.h:166
LARGE_INTEGER BeyondLastByte1
Definition: cctypes.h:78
unsigned char BOOLEAN
_In_ UINT _In_ UINT _In_ PNDIS_PACKET _In_ UINT _Out_ PUINT BytesCopied
Definition: ndis.h:3149
Definition: bufpool.h:45
void * PVOID
Definition: retypes.h:9
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
LIST_ENTRY CacheMapVacbListHead
Definition: cc.h:190
int64_t LONGLONG
Definition: typedefs.h:66
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:24
NTSTATUS NTAPI CcRosReleaseVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, PROS_VACB Vacb, BOOLEAN Valid, BOOLEAN Dirty, BOOLEAN Mapped)
Definition: view.c:421
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
LARGE_INTEGER FileOffset1
Definition: cctypes.h:77
Definition: typedefs.h:117
Status
Definition: gdiplustypes.h:24
FORCEINLINE BOOLEAN DoRangesIntersect(_In_ LONGLONG Offset1, _In_ LONGLONG Length1, _In_ LONGLONG Offset2, _In_ LONGLONG Length2)
Definition: cc.h:481
#define ROUND_DOWN(n, align)
Definition: eventvwr.h:30
NTSTATUS ReadWriteOrZero(_Inout_ PVOID BaseAddress, _Inout_opt_ PVOID Buffer, _In_ ULONG Length, _In_ CC_COPY_OPERATION Operation)
Definition: copy.c:226
BOOLEAN Valid
Definition: cc.h:209
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:151
#define min(a, b)
Definition: monoChain.cc:55
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
LARGE_INTEGER FileOffset
Definition: cc.h:222
LARGE_INTEGER FileOffset2
Definition: cctypes.h:79
#define VACB_MAPPING_GRANULARITY
unsigned int ULONG
Definition: retypes.h:1
_In_ FLT_SET_CONTEXT_OPERATION Operation
Definition: fltkernel.h:1468
KSPIN_LOCK CacheMapLock
Definition: cc.h:193
return STATUS_SUCCESS
Definition: btrfs.c:2725
NTSTATUS NTAPI CcRosRequestVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset, PVOID *BaseAddress, PBOOLEAN UptoDate, PROS_VACB *Vacb)
Definition: view.c:996
NTSTATUS NTAPI CcReadVirtualAddress(PROS_VACB Vacb)
Definition: copy.c:81
LONGLONG QuadPart
Definition: typedefs.h:112
IN BOOLEAN Wait
Definition: fatprocs.h:1529

Referenced by CcCopyRead(), CcCopyWrite(), and CcZeroData().

◆ CcCopyRead()

BOOLEAN NTAPI CcCopyRead ( IN PFILE_OBJECT  FileObject,
IN PLARGE_INTEGER  FileOffset,
IN ULONG  Length,
IN BOOLEAN  Wait,
OUT PVOID  Buffer,
OUT PIO_STATUS_BLOCK  IoStatus 
)

Definition at line 807 of file copy.c.

814 {
815  CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%I64d Length=%lu Wait=%d\n",
816  FileObject, FileOffset->QuadPart, Length, Wait);
817 
818  DPRINT("CcCopyRead(FileObject 0x%p, FileOffset %I64x, "
819  "Length %lu, Wait %u, Buffer 0x%p, IoStatus 0x%p)\n",
820  FileObject, FileOffset->QuadPart, Length, Wait,
821  Buffer, IoStatus);
822 
823  return CcCopyData(FileObject,
824  FileOffset->QuadPart,
825  Buffer,
826  Length,
828  Wait,
829  IoStatus);
830 }
BOOLEAN CcCopyData(_In_ PFILE_OBJECT FileObject, _In_ LONGLONG FileOffset, _Inout_ PVOID Buffer, _In_ LONGLONG Length, _In_ CC_COPY_OPERATION Operation, _In_ BOOLEAN Wait, _Out_ PIO_STATUS_BLOCK IoStatus)
Definition: copy.c:258
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN OUT PIO_STATUS_BLOCK IoStatus
Definition: fatprocs.h:2650
void DPRINT(...)
Definition: polytest.cpp:61
Definition: bufpool.h:45
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
#define CC_API_DEBUG
Definition: cc.h:11
#define CCTRACE(x, fmt,...)
Definition: cc.h:36
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:151
IN BOOLEAN Wait
Definition: fatprocs.h:1529

Referenced by CcFastCopyRead().

◆ CcCopyWrite()

BOOLEAN NTAPI CcCopyWrite ( IN PFILE_OBJECT  FileObject,
IN PLARGE_INTEGER  FileOffset,
IN ULONG  Length,
IN BOOLEAN  Wait,
IN PVOID  Buffer 
)

Definition at line 837 of file copy.c.

843 {
845 
846  CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%I64d Length=%lu Wait=%d Buffer=%p\n",
847  FileObject, FileOffset->QuadPart, Length, Wait, Buffer);
848 
849  DPRINT("CcCopyWrite(FileObject 0x%p, FileOffset %I64x, "
850  "Length %lu, Wait %u, Buffer 0x%p)\n",
851  FileObject, FileOffset->QuadPart, Length, Wait, Buffer);
852 
853  return CcCopyData(FileObject,
854  FileOffset->QuadPart,
855  Buffer,
856  Length,
858  Wait,
859  &IoStatus);
860 }
BOOLEAN CcCopyData(_In_ PFILE_OBJECT FileObject, _In_ LONGLONG FileOffset, _Inout_ PVOID Buffer, _In_ LONGLONG Length, _In_ CC_COPY_OPERATION Operation, _In_ BOOLEAN Wait, _Out_ PIO_STATUS_BLOCK IoStatus)
Definition: copy.c:258
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN OUT PIO_STATUS_BLOCK IoStatus
Definition: fatprocs.h:2650
void DPRINT(...)
Definition: polytest.cpp:61
Definition: bufpool.h:45
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
#define CC_API_DEBUG
Definition: cc.h:11
#define CCTRACE(x, fmt,...)
Definition: cc.h:36
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:151
IN BOOLEAN Wait
Definition: fatprocs.h:1529

Referenced by CcFastCopyWrite().

◆ CcDeferWrite()

VOID NTAPI CcDeferWrite ( IN PFILE_OBJECT  FileObject,
IN PCC_POST_DEFERRED_WRITE  PostRoutine,
IN PVOID  Context1,
IN PVOID  Context2,
IN ULONG  BytesToWrite,
IN BOOLEAN  Retrying 
)

Definition at line 867 of file copy.c.

874 {
875  KIRQL OldIrql;
878 
879  CCTRACE(CC_API_DEBUG, "FileObject=%p PostRoutine=%p Context1=%p Context2=%p BytesToWrite=%lu Retrying=%d\n",
880  FileObject, PostRoutine, Context1, Context2, BytesToWrite, Retrying);
881 
882  /* Try to allocate a context for queueing the write operation */
884  /* If it failed, immediately execute the operation! */
885  if (Context == NULL)
886  {
887  PostRoutine(Context1, Context2);
888  return;
889  }
890 
891  Fcb = FileObject->FsContext;
892 
893  /* Otherwise, initialize the context */
895  Context->NodeTypeCode = NODE_TYPE_DEFERRED_WRITE;
896  Context->NodeByteSize = sizeof(DEFERRED_WRITE);
897  Context->FileObject = FileObject;
898  Context->PostRoutine = PostRoutine;
899  Context->Context1 = Context1;
900  Context->Context2 = Context2;
901  Context->BytesToWrite = BytesToWrite;
903 
904  /* And queue it */
905  if (Retrying)
906  {
907  /* To the top, if that's a retry */
909  &Context->DeferredWriteLinks,
911  }
912  else
913  {
914  /* To the bottom, if that's a first time */
916  &Context->DeferredWriteLinks,
918  }
919 
920  /* Try to execute the posted writes */
922 
923  /* Schedule a lazy writer run to handle deferred writes */
925  if (!LazyWriter.ScanActive)
926  {
928  }
930 }
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
PLIST_ENTRY NTAPI ExInterlockedInsertTailList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:140
VOID CcPostDeferredWrites(VOID)
Definition: copy.c:413
UCHAR KIRQL
Definition: env_spec_w32.h:591
PLIST_ENTRY NTAPI ExInterlockedInsertHeadList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:114
LAZY_WRITER LazyWriter
Definition: lazywrite.c:37
smooth NULL
Definition: ftsmooth.c:416
#define NODE_TYPE_DEFERRED_WRITE
Definition: cc.h:287
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
#define CC_API_DEBUG
Definition: cc.h:11
struct _DEFERRED_WRITE DEFERRED_WRITE
LIST_ENTRY CcDeferredWrites
Definition: view.c:61
BOOLEAN ScanActive
Definition: cc.h:247
VOID FASTCALL KeReleaseQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber, IN KIRQL OldIrql)
Definition: spinlock.c:154
#define CCTRACE(x, fmt,...)
Definition: cc.h:36
#define FSRTL_FLAG_LIMIT_MODIFIED_PAGES
Definition: fsrtltypes.h:47
KSPIN_LOCK CcDeferredWriteSpinLock
Definition: view.c:62
ULONG Flags
Definition: ntfs.h:520
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
KIRQL FASTCALL KeAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
Definition: spinlock.c:108
_In_ PNET_PNP_EVENT _In_ PTDI_PNP_CONTEXT _In_ PTDI_PNP_CONTEXT Context2
Definition: tdikrnl.h:1094
VOID CcScheduleLazyWriteScan(IN BOOLEAN NoDelay)
Definition: lazywrite.c:200
_In_ PNET_PNP_EVENT _In_ PTDI_PNP_CONTEXT Context1
Definition: tdikrnl.h:1094
struct tagContext Context
Definition: acpixf.h:1020
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
_In_ PFCB Fcb
Definition: cdprocs.h:151

◆ CcFastCopyRead()

VOID NTAPI CcFastCopyRead ( IN PFILE_OBJECT  FileObject,
IN ULONG  FileOffset,
IN ULONG  Length,
IN ULONG  PageCount,
OUT PVOID  Buffer,
OUT PIO_STATUS_BLOCK  IoStatus 
)

Definition at line 937 of file copy.c.

944 {
945  LARGE_INTEGER LargeFileOffset;
947 
948  CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%lu Length=%lu PageCount=%lu Buffer=%p\n",
949  FileObject, FileOffset, Length, PageCount, Buffer);
950 
951  DBG_UNREFERENCED_PARAMETER(PageCount);
952 
953  LargeFileOffset.QuadPart = FileOffset;
955  &LargeFileOffset,
956  Length,
957  TRUE,
958  Buffer,
959  IoStatus);
960  ASSERT(Success == TRUE);
961 }
#define TRUE
Definition: types.h:120
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN OUT PIO_STATUS_BLOCK IoStatus
Definition: fatprocs.h:2650
#define DBG_UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:325
BOOLEAN NTAPI CcCopyRead(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus)
Definition: copy.c:807
unsigned char BOOLEAN
Definition: bufpool.h:45
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
#define CC_API_DEBUG
Definition: cc.h:11
#define CCTRACE(x, fmt,...)
Definition: cc.h:36
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:151
LONGLONG QuadPart
Definition: typedefs.h:112

◆ CcFastCopyWrite()

VOID NTAPI CcFastCopyWrite ( IN PFILE_OBJECT  FileObject,
IN ULONG  FileOffset,
IN ULONG  Length,
IN PVOID  Buffer 
)

Definition at line 968 of file copy.c.

973 {
974  LARGE_INTEGER LargeFileOffset;
976 
977  CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%lu Length=%lu Buffer=%p\n",
979 
980  LargeFileOffset.QuadPart = FileOffset;
982  &LargeFileOffset,
983  Length,
984  TRUE,
985  Buffer);
986  ASSERT(Success == TRUE);
987 }
#define TRUE
Definition: types.h:120
unsigned char BOOLEAN
Definition: bufpool.h:45
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
#define CC_API_DEBUG
Definition: cc.h:11
#define CCTRACE(x, fmt,...)
Definition: cc.h:36
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:151
BOOLEAN NTAPI CcCopyWrite(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN PVOID Buffer)
Definition: copy.c:837
LONGLONG QuadPart
Definition: typedefs.h:112

◆ CcInitCacheZeroPage()

VOID NTAPI CcInitCacheZeroPage ( VOID  )

Definition at line 63 of file copy.c.

65 {
67 
69  //MI_SET_PROCESS2(PsGetCurrentProcess()->ImageFileName);
71  if (!NT_SUCCESS(Status))
72  {
73  DbgPrint("Can't allocate CcZeroPage.\n");
74  KeBugCheck(CACHE_MANAGER);
75  }
77 }
#define TRUE
Definition: types.h:120
#define DbgPrint
Definition: loader.c:25
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI MmRequestPageMemoryConsumer(ULONG Consumer, BOOLEAN MyWait, PPFN_NUMBER AllocatedPage)
Definition: balance.c:229
#define MC_SYSTEM
Definition: mm.h:95
VOID NTAPI MiZeroPhysicalPage(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:122
VOID NTAPI KeBugCheck(ULONG BugCheckCode)
Definition: bug.c:1469
#define MI_SET_USAGE(x)
Definition: mm.h:253
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:24
static PFN_NUMBER CcZeroPage
Definition: copy.c:19
Status
Definition: gdiplustypes.h:24

Referenced by CcInitView().

◆ CcPerformReadAhead()

VOID CcPerformReadAhead ( IN PFILE_OBJECT  FileObject)

Definition at line 487 of file copy.c.

489 {
491  LONGLONG CurrentOffset;
492  KIRQL OldIrql;
493  PROS_SHARED_CACHE_MAP SharedCacheMap;
494  PROS_VACB Vacb;
495  ULONG PartialLength;
497  BOOLEAN Valid;
498  ULONG Length;
499  PPRIVATE_CACHE_MAP PrivateCacheMap;
500  BOOLEAN Locked;
501 
502  SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
503 
504  /* Critical:
505  * PrivateCacheMap might disappear in-between if the handle
506  * to the file is closed (private is attached to the handle not to
507  * the file), so we need to lock the master lock while we deal with
508  * it. It won't disappear without attempting to lock such lock.
509  */
511  PrivateCacheMap = FileObject->PrivateCacheMap;
512  /* If the handle was closed since the read ahead was scheduled, just quit */
513  if (PrivateCacheMap == NULL)
514  {
517  return;
518  }
519  /* Otherwise, extract read offset and length and release private map */
520  else
521  {
523  CurrentOffset = PrivateCacheMap->ReadAheadOffset[1].QuadPart;
524  Length = PrivateCacheMap->ReadAheadLength[1];
526  }
528 
529  /* Time to go! */
530  DPRINT("Doing ReadAhead for %p\n", FileObject);
531  /* Lock the file, first */
532  if (!SharedCacheMap->Callbacks->AcquireForReadAhead(SharedCacheMap->LazyWriteContext, FALSE))
533  {
534  Locked = FALSE;
535  goto Clear;
536  }
537 
538  /* Remember it's locked */
539  Locked = TRUE;
540 
541  /* Don't read past the end of the file */
542  if (CurrentOffset >= SharedCacheMap->FileSize.QuadPart)
543  {
544  goto Clear;
545  }
546  if (CurrentOffset + Length > SharedCacheMap->FileSize.QuadPart)
547  {
548  Length = SharedCacheMap->FileSize.QuadPart - CurrentOffset;
549  }
550 
551  /* Next of the algorithm will lock like CcCopyData with the slight
552  * difference that we don't copy data back to an user-backed buffer
553  * We just bring data into Cc
554  */
555  PartialLength = CurrentOffset % VACB_MAPPING_GRANULARITY;
556  if (PartialLength != 0)
557  {
558  PartialLength = min(Length, VACB_MAPPING_GRANULARITY - PartialLength);
559  Status = CcRosRequestVacb(SharedCacheMap,
560  ROUND_DOWN(CurrentOffset,
562  &BaseAddress,
563  &Valid,
564  &Vacb);
565  if (!NT_SUCCESS(Status))
566  {
567  DPRINT1("Failed to request VACB: %lx!\n", Status);
568  goto Clear;
569  }
570 
571  if (!Valid)
572  {
574  if (!NT_SUCCESS(Status))
575  {
576  CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
577  DPRINT1("Failed to read data: %lx!\n", Status);
578  goto Clear;
579  }
580  }
581 
582  CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
583 
584  Length -= PartialLength;
585  CurrentOffset += PartialLength;
586  }
587 
588  while (Length > 0)
589  {
590  ASSERT(CurrentOffset % VACB_MAPPING_GRANULARITY == 0);
591  PartialLength = min(VACB_MAPPING_GRANULARITY, Length);
592  Status = CcRosRequestVacb(SharedCacheMap,
593  CurrentOffset,
594  &BaseAddress,
595  &Valid,
596  &Vacb);
597  if (!NT_SUCCESS(Status))
598  {
599  DPRINT1("Failed to request VACB: %lx!\n", Status);
600  goto Clear;
601  }
602 
603  if (!Valid)
604  {
606  if (!NT_SUCCESS(Status))
607  {
608  CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
609  DPRINT1("Failed to read data: %lx!\n", Status);
610  goto Clear;
611  }
612  }
613 
614  CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
615 
616  Length -= PartialLength;
617  CurrentOffset += PartialLength;
618  }
619 
620 Clear:
621  /* See previous comment about private cache map */
623  PrivateCacheMap = FileObject->PrivateCacheMap;
624  if (PrivateCacheMap != NULL)
625  {
626  /* Mark read ahead as unactive */
628  InterlockedAnd((volatile long *)&PrivateCacheMap->UlongFlags, ~PRIVATE_CACHE_MAP_READ_AHEAD_ACTIVE);
630  }
632 
633  /* If file was locked, release it */
634  if (Locked)
635  {
636  SharedCacheMap->Callbacks->ReleaseFromReadAhead(SharedCacheMap->LazyWriteContext);
637  }
638 
639  /* And drop our extra reference (See: CcScheduleReadAhead) */
641 
642  return;
643 }
#define InterlockedAnd
Definition: interlocked.h:62
#define TRUE
Definition: types.h:120
Definition: cc.h:202
VOID NTAPI KeAcquireSpinLockAtDpcLevel(IN PKSPIN_LOCK SpinLock)
Definition: spinlock.c:192
LONG NTSTATUS
Definition: precomp.h:26
VOID NTAPI ObDereferenceObject(IN PVOID Object)
Definition: obref.c:375
UCHAR KIRQL
Definition: env_spec_w32.h:591
_In_ PMEMORY_AREA _In_ PVOID _In_ BOOLEAN Locked
Definition: newmm.h:260
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
PCACHE_MANAGER_CALLBACKS Callbacks
Definition: cc.h:182
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
KSPIN_LOCK ReadAheadSpinLock
Definition: cctypes.h:83
int64_t LONGLONG
Definition: typedefs.h:66
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:24
NTSTATUS NTAPI CcRosReleaseVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, PROS_VACB Vacb, BOOLEAN Valid, BOOLEAN Dirty, BOOLEAN Mapped)
Definition: view.c:421
VOID NTAPI KeReleaseSpinLockFromDpcLevel(IN PKSPIN_LOCK SpinLock)
Definition: spinlock.c:215
VOID FASTCALL KeReleaseQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber, IN KIRQL OldIrql)
Definition: spinlock.c:154
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
PACQUIRE_FOR_READ_AHEAD AcquireForReadAhead
Definition: cctypes.h:41
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
PRELEASE_FROM_READ_AHEAD ReleaseFromReadAhead
Definition: cctypes.h:42
KIRQL FASTCALL KeAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
Definition: spinlock.c:108
Status
Definition: gdiplustypes.h:24
#define ROUND_DOWN(n, align)
Definition: eventvwr.h:30
LARGE_INTEGER ReadAheadOffset[2]
Definition: cctypes.h:81
#define min(a, b)
Definition: monoChain.cc:55
#define DPRINT1
Definition: precomp.h:8
#define VACB_MAPPING_GRANULARITY
PVOID LazyWriteContext
Definition: cc.h:183
LARGE_INTEGER FileSize
Definition: cc.h:175
unsigned int ULONG
Definition: retypes.h:1
void Clear(USHORT Window)
Definition: hardware.c:705
ULONG UlongFlags
Definition: cctypes.h:73
#define PRIVATE_CACHE_MAP_READ_AHEAD_ACTIVE
Definition: cctypes.h:64
NTSTATUS NTAPI CcRosRequestVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset, PVOID *BaseAddress, PBOOLEAN UptoDate, PROS_VACB *Vacb)
Definition: view.c:996
NTSTATUS NTAPI CcReadVirtualAddress(PROS_VACB Vacb)
Definition: copy.c:81
ULONG ReadAheadLength[2]
Definition: cctypes.h:82
LONGLONG QuadPart
Definition: typedefs.h:112

Referenced by CcWorkerThread().

◆ CcPostDeferredWrites()

VOID CcPostDeferredWrites ( VOID  )

Definition at line 413 of file copy.c.

414 {
415  ULONG WrittenBytes;
416 
417  /* We'll try to write as much as we can */
418  WrittenBytes = 0;
419  while (TRUE)
420  {
421  KIRQL OldIrql;
422  PLIST_ENTRY ListEntry;
423  PDEFERRED_WRITE DeferredWrite;
424 
425  DeferredWrite = NULL;
426 
427  /* Lock our deferred writes list */
429  for (ListEntry = CcDeferredWrites.Flink;
430  ListEntry != &CcDeferredWrites;
431  ListEntry = ListEntry->Flink)
432  {
433  /* Extract an entry */
434  DeferredWrite = CONTAINING_RECORD(ListEntry, DEFERRED_WRITE, DeferredWriteLinks);
435 
436  /* Compute the modified bytes, based on what we already wrote */
437  WrittenBytes += DeferredWrite->BytesToWrite;
438  /* We overflowed, give up */
439  if (WrittenBytes < DeferredWrite->BytesToWrite)
440  {
441  DeferredWrite = NULL;
442  break;
443  }
444 
445  /* Check we can write */
446  if (CcCanIWrite(DeferredWrite->FileObject, WrittenBytes, FALSE, RetryForceCheckPerFile))
447  {
448  /* We can, so remove it from the list and stop looking for entry */
449  RemoveEntryList(&DeferredWrite->DeferredWriteLinks);
450  break;
451  }
452 
453  /* If we don't accept modified pages, stop here */
454  if (!DeferredWrite->LimitModifiedPages)
455  {
456  DeferredWrite = NULL;
457  break;
458  }
459 
460  /* Reset count as nothing was written yet */
461  WrittenBytes -= DeferredWrite->BytesToWrite;
462  DeferredWrite = NULL;
463  }
465 
466  /* Nothing to write found, give up */
467  if (DeferredWrite == NULL)
468  {
469  break;
470  }
471 
472  /* If we have an event, set it and quit */
473  if (DeferredWrite->Event)
474  {
475  KeSetEvent(DeferredWrite->Event, IO_NO_INCREMENT, FALSE);
476  }
477  /* Otherwise, call the write routine and free the context */
478  else
479  {
480  DeferredWrite->PostRoutine(DeferredWrite->Context1, DeferredWrite->Context2);
481  ExFreePoolWithTag(DeferredWrite, 'CcDw');
482  }
483  }
484 }
BOOLEAN LimitModifiedPages
Definition: cctypes.h:178
#define TRUE
Definition: types.h:120
BOOLEAN NTAPI CcCanIWrite(IN PFILE_OBJECT FileObject, IN ULONG BytesToWrite, IN BOOLEAN Wait, IN BOOLEAN Retrying)
Definition: copy.c:650
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
UCHAR KIRQL
Definition: env_spec_w32.h:591
smooth NULL
Definition: ftsmooth.c:416
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
LIST_ENTRY DeferredWriteLinks
Definition: cctypes.h:173
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
LIST_ENTRY CcDeferredWrites
Definition: view.c:61
KSPIN_LOCK CcDeferredWriteSpinLock
Definition: view.c:62
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
Definition: typedefs.h:117
PFILE_OBJECT FileObject
Definition: cctypes.h:171
PVOID Context1
Definition: cctypes.h:176
PCC_POST_DEFERRED_WRITE PostRoutine
Definition: cctypes.h:175
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:565
ULONG BytesToWrite
Definition: cctypes.h:172
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
PKEVENT Event
Definition: cctypes.h:174
PVOID Context2
Definition: cctypes.h:177

Referenced by CcCanIWrite(), CcDeferWrite(), and CcLazyWriteScan().

◆ CcReadVirtualAddress()

NTSTATUS NTAPI CcReadVirtualAddress ( PROS_VACB  Vacb)

Definition at line 81 of file copy.c.

83 {
84  ULONG Size;
85  PMDL Mdl;
88  KEVENT Event;
89  ULARGE_INTEGER LargeSize;
90 
92  if (LargeSize.QuadPart > VACB_MAPPING_GRANULARITY)
93  {
95  }
96  Size = LargeSize.LowPart;
97 
100  ASSERT(Size > 0);
101 
102  Mdl = IoAllocateMdl(Vacb->BaseAddress, Size, FALSE, FALSE, NULL);
103  if (!Mdl)
104  {
106  }
107 
109  _SEH2_TRY
110  {
112  }
114  {
116  DPRINT1("MmProbeAndLockPages failed with: %lx for %p (%p, %p)\n", Status, Mdl, Vacb, Vacb->BaseAddress);
117  KeBugCheck(CACHE_MANAGER);
118  } _SEH2_END;
119 
120  if (NT_SUCCESS(Status))
121  {
122  Mdl->MdlFlags |= MDL_IO_PAGE_READ;
125  if (Status == STATUS_PENDING)
126  {
128  Status = IoStatus.Status;
129  }
130 
131  MmUnlockPages(Mdl);
132  }
133 
134  IoFreeMdl(Mdl);
135 
137  {
138  DPRINT1("IoPageRead failed, Status %x\n", Status);
139  return Status;
140  }
141 
143  {
144  RtlZeroMemory((char*)Vacb->BaseAddress + Size,
146  }
147 
148  return STATUS_SUCCESS;
149 }
#define MDL_IO_PAGE_READ
Definition: mmtypes.h:24
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
PVOID BaseAddress
Definition: cc.h:205
LARGE_INTEGER SectionSize
Definition: cc.h:177
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN OUT PIO_STATUS_BLOCK IoStatus
Definition: fatprocs.h:2650
LONG NTSTATUS
Definition: precomp.h:26
$ULONG LowPart
Definition: ntbasedef.h:576
VOID NTAPI MmUnlockPages(IN PMDL Mdl)
Definition: mdlsup.c:1439
NTSTATUS NTAPI IoPageRead(IN PFILE_OBJECT FileObject, IN PMDL Mdl, IN PLARGE_INTEGER Offset, IN PKEVENT Event, IN PIO_STATUS_BLOCK StatusBlock)
Definition: iofunc.c:1091
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
_SEH2_TRY
Definition: create.c:4250
#define STATUS_END_OF_FILE
Definition: shellext.h:62
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:434
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
smooth NULL
Definition: ftsmooth.c:416
VOID NTAPI KeBugCheck(ULONG BugCheckCode)
Definition: bug.c:1469
PROS_SHARED_CACHE_MAP SharedCacheMap
Definition: cc.h:226
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:24
#define STATUS_PENDING
Definition: ntstatus.h:82
VOID NTAPI IoFreeMdl(PMDL Mdl)
Definition: iomdl.c:146
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
Status
Definition: gdiplustypes.h:24
PMDL NTAPI IoAllocateMdl(IN PVOID VirtualAddress, IN ULONG Length, IN BOOLEAN SecondaryBuffer, IN BOOLEAN ChargeQuota, IN PIRP Irp)
Definition: iomdl.c:22
_SEH2_END
Definition: create.c:4424
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
VOID NTAPI MmProbeAndLockPages(IN PMDL Mdl, IN KPROCESSOR_MODE AccessMode, IN LOCK_OPERATION Operation)
Definition: mdlsup.c:935
#define ROUND_TO_PAGES(Size)
#define DPRINT1
Definition: precomp.h:8
LARGE_INTEGER FileOffset
Definition: cc.h:222
#define VACB_MAPPING_GRANULARITY
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
PFILE_OBJECT FileObject
Definition: cc.h:178
return STATUS_SUCCESS
Definition: btrfs.c:2725
LONGLONG QuadPart
Definition: typedefs.h:112

Referenced by CcCopyData(), CcPerformReadAhead(), CcpMapData(), and MiReadPage().

◆ CcWriteVirtualAddress()

NTSTATUS NTAPI CcWriteVirtualAddress ( PROS_VACB  Vacb)

Definition at line 153 of file copy.c.

155 {
156  ULONG Size;
157  PMDL Mdl;
160  KEVENT Event;
161  ULARGE_INTEGER LargeSize;
162 
163  LargeSize.QuadPart = Vacb->SharedCacheMap->SectionSize.QuadPart - Vacb->FileOffset.QuadPart;
164  if (LargeSize.QuadPart > VACB_MAPPING_GRANULARITY)
165  {
167  }
168  Size = LargeSize.LowPart;
169  //
170  // Nonpaged pool PDEs in ReactOS must actually be synchronized between the
171  // MmGlobalPageDirectory and the real system PDE directory. What a mess...
172  //
173  {
174  ULONG i = 0;
175  do
176  {
178  } while (++i < (Size >> PAGE_SHIFT));
179  }
180 
183  ASSERT(Size > 0);
184 
185  Mdl = IoAllocateMdl(Vacb->BaseAddress, Size, FALSE, FALSE, NULL);
186  if (!Mdl)
187  {
189  }
190 
192  _SEH2_TRY
193  {
195  }
197  {
199  DPRINT1("MmProbeAndLockPages failed with: %lx for %p (%p, %p)\n", Status, Mdl, Vacb, Vacb->BaseAddress);
200  KeBugCheck(CACHE_MANAGER);
201  } _SEH2_END;
202 
203  if (NT_SUCCESS(Status))
204  {
207  if (Status == STATUS_PENDING)
208  {
210  Status = IoStatus.Status;
211  }
212 
213  MmUnlockPages(Mdl);
214  }
215  IoFreeMdl(Mdl);
217  {
218  DPRINT1("IoPageWrite failed, Status %x\n", Status);
219  return Status;
220  }
221 
222  return STATUS_SUCCESS;
223 }
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
PVOID BaseAddress
Definition: cc.h:205
LARGE_INTEGER SectionSize
Definition: cc.h:177
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN OUT PIO_STATUS_BLOCK IoStatus
Definition: fatprocs.h:2650
LONG NTSTATUS
Definition: precomp.h:26
$ULONG LowPart
Definition: ntbasedef.h:576
VOID NTAPI MmUnlockPages(IN PMDL Mdl)
Definition: mdlsup.c:1439
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
_SEH2_TRY
Definition: create.c:4250
#define STATUS_END_OF_FILE
Definition: shellext.h:62
uint32_t ULONG_PTR
Definition: typedefs.h:63
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:434
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
smooth NULL
Definition: ftsmooth.c:416
VOID NTAPI KeBugCheck(ULONG BugCheckCode)
Definition: bug.c:1469
PROS_SHARED_CACHE_MAP SharedCacheMap
Definition: cc.h:226
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:24
#define STATUS_PENDING
Definition: ntstatus.h:82
VOID NTAPI IoFreeMdl(PMDL Mdl)
Definition: iomdl.c:146
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
Status
Definition: gdiplustypes.h:24
PMDL NTAPI IoAllocateMdl(IN PVOID VirtualAddress, IN ULONG Length, IN BOOLEAN SecondaryBuffer, IN BOOLEAN ChargeQuota, IN PIRP Irp)
Definition: iomdl.c:22
_SEH2_END
Definition: create.c:4424
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
VOID NTAPI MmProbeAndLockPages(IN PMDL Mdl, IN KPROCESSOR_MODE AccessMode, IN LOCK_OPERATION Operation)
Definition: mdlsup.c:935
#define ROUND_TO_PAGES(Size)
PFN_NUMBER NTAPI MmGetPfnForProcess(struct _EPROCESS *Process, PVOID Address)
NTSTATUS NTAPI IoSynchronousPageWrite(IN PFILE_OBJECT FileObject, IN PMDL Mdl, IN PLARGE_INTEGER Offset, IN PKEVENT Event, IN PIO_STATUS_BLOCK StatusBlock)
Definition: iofunc.c:1036
#define DPRINT1
Definition: precomp.h:8
LARGE_INTEGER FileOffset
Definition: cc.h:222
#define VACB_MAPPING_GRANULARITY
unsigned int ULONG
Definition: retypes.h:1
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
PFILE_OBJECT FileObject
Definition: cc.h:178
return STATUS_SUCCESS
Definition: btrfs.c:2725
LONGLONG QuadPart
Definition: typedefs.h:112

Referenced by CcRosFlushVacb().

◆ CcZeroData()

BOOLEAN NTAPI CcZeroData ( IN PFILE_OBJECT  FileObject,
IN PLARGE_INTEGER  StartOffset,
IN PLARGE_INTEGER  EndOffset,
IN BOOLEAN  Wait 
)

Definition at line 994 of file copy.c.

999 {
1000  NTSTATUS Status;
1001  LARGE_INTEGER WriteOffset;
1002  LONGLONG Length;
1003  ULONG CurrentLength;
1004  PMDL Mdl;
1005  ULONG i;
1007  KEVENT Event;
1008 
1009  CCTRACE(CC_API_DEBUG, "FileObject=%p StartOffset=%I64u EndOffset=%I64u Wait=%d\n",
1010  FileObject, StartOffset->QuadPart, EndOffset->QuadPart, Wait);
1011 
1012  DPRINT("CcZeroData(FileObject 0x%p, StartOffset %I64x, EndOffset %I64x, "
1013  "Wait %u)\n", FileObject, StartOffset->QuadPart, EndOffset->QuadPart,
1014  Wait);
1015 
1016  Length = EndOffset->QuadPart - StartOffset->QuadPart;
1017  WriteOffset.QuadPart = StartOffset->QuadPart;
1018 
1019  if (FileObject->SectionObjectPointer->SharedCacheMap == NULL)
1020  {
1021  /* File is not cached */
1022 
1023  Mdl = _alloca(MmSizeOfMdl(NULL, MAX_ZERO_LENGTH));
1024 
1025  while (Length > 0)
1026  {
1027  if (Length + WriteOffset.QuadPart % PAGE_SIZE > MAX_ZERO_LENGTH)
1028  {
1029  CurrentLength = MAX_ZERO_LENGTH - WriteOffset.QuadPart % PAGE_SIZE;
1030  }
1031  else
1032  {
1033  CurrentLength = Length;
1034  }
1035  MmInitializeMdl(Mdl, (PVOID)(ULONG_PTR)WriteOffset.QuadPart, CurrentLength);
1036  Mdl->MdlFlags |= (MDL_PAGES_LOCKED | MDL_IO_PAGE_READ);
1037  for (i = 0; i < ((Mdl->Size - sizeof(MDL)) / sizeof(ULONG)); i++)
1038  {
1039  ((PPFN_NUMBER)(Mdl + 1))[i] = CcZeroPage;
1040  }
1042  Status = IoSynchronousPageWrite(FileObject, Mdl, &WriteOffset, &Event, &Iosb);
1043  if (Status == STATUS_PENDING)
1044  {
1046  Status = Iosb.Status;
1047  }
1048  if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
1049  {
1050  MmUnmapLockedPages(Mdl->MappedSystemVa, Mdl);
1051  }
1052  if (!NT_SUCCESS(Status))
1053  {
1054  return FALSE;
1055  }
1056  WriteOffset.QuadPart += CurrentLength;
1057  Length -= CurrentLength;
1058  }
1059  }
1060  else
1061  {
1063 
1064  return CcCopyData(FileObject,
1065  WriteOffset.QuadPart,
1066  NULL,
1067  Length,
1069  Wait,
1070  &IoStatus);
1071  }
1072 
1073  return TRUE;
1074 }
#define MDL_IO_PAGE_READ
Definition: mmtypes.h:24
BOOLEAN CcCopyData(_In_ PFILE_OBJECT FileObject, _In_ LONGLONG FileOffset, _Inout_ PVOID Buffer, _In_ LONGLONG Length, _In_ CC_COPY_OPERATION Operation, _In_ BOOLEAN Wait, _Out_ PIO_STATUS_BLOCK IoStatus)
Definition: copy.c:258
#define TRUE
Definition: types.h:120
#define MmInitializeMdl(_MemoryDescriptorList, _BaseVa, _Length)
IN PLARGE_INTEGER IN ULONG IN BOOLEAN IN ULONG IN BOOLEAN OUT PIO_STATUS_BLOCK IoStatus
Definition: fatprocs.h:2650
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
#define MDL_MAPPED_TO_SYSTEM_VA
Definition: mmtypes.h:18
uint32_t ULONG_PTR
Definition: typedefs.h:63
ULONG * PPFN_NUMBER
Definition: ke.h:8
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
VOID NTAPI MmUnmapLockedPages(IN PVOID BaseAddress, IN PMDL Mdl)
Definition: mdlsup.c:841
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:434
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
int64_t LONGLONG
Definition: typedefs.h:66
#define CC_API_DEBUG
Definition: cc.h:11
return Iosb
Definition: create.c:4426
#define MDL_PAGES_LOCKED
Definition: mmtypes.h:19
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:24
#define STATUS_PENDING
Definition: ntstatus.h:82
#define CCTRACE(x, fmt,...)
Definition: cc.h:36
static PFN_NUMBER CcZeroPage
Definition: copy.c:19
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
MDL
Definition: mmtypes.h:117
SIZE_T NTAPI MmSizeOfMdl(IN PVOID Base, IN SIZE_T Length)
Definition: mdlsup.c:413
#define PAGE_SIZE
Definition: env_spec_w32.h:49
Status
Definition: gdiplustypes.h:24
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
NTSTATUS NTAPI IoSynchronousPageWrite(IN PFILE_OBJECT FileObject, IN PMDL Mdl, IN PLARGE_INTEGER Offset, IN PKEVENT Event, IN PIO_STATUS_BLOCK StatusBlock)
Definition: iofunc.c:1036
unsigned int ULONG
Definition: retypes.h:1
LONGLONG QuadPart
Definition: typedefs.h:112
IN BOOLEAN Wait
Definition: fatprocs.h:1529
#define MAX_ZERO_LENGTH
Definition: copy.c:21

◆ MiZeroPhysicalPage()

VOID NTAPI MiZeroPhysicalPage ( IN PFN_NUMBER  PageFrameIndex)

Definition at line 122 of file pfnlist.c.

123 {
124  KIRQL OldIrql;
127 
128  /* Map in hyperspace, then wipe it using XMMI or MEMSET */
133 }
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define PsGetCurrentProcess
Definition: psfuncs.h:17
PVOID NTAPI MiMapPageInHyperSpace(IN PEPROCESS Process, IN PFN_NUMBER Page, IN PKIRQL OldIrql)
Definition: hypermap.c:30
VOID FASTCALL KeZeroPages(IN PVOID Address, IN ULONG Size)
Definition: stubs.c:82
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
VOID NTAPI MiUnmapPageInHyperSpace(IN PEPROCESS Process, IN PVOID Address, IN KIRQL OldIrql)
Definition: hypermap.c:93
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
#define PAGE_SIZE
Definition: env_spec_w32.h:49
_In_ ULONG _In_ BOOLEAN _Must_inspect_result_ PVOID * VirtualAddress
Definition: ndis.h:3773
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219

Referenced by CcInitCacheZeroPage(), MiAllocatePagesForMdl(), MiSessionCreateInternal(), MiSessionInitializeWorkingSetList(), and MmCreateProcessAddressSpace().

◆ ReadWriteOrZero()

NTSTATUS ReadWriteOrZero ( _Inout_ PVOID  BaseAddress,
_Inout_opt_ PVOID  Buffer,
_In_ ULONG  Length,
_In_ CC_COPY_OPERATION  Operation 
)

Definition at line 226 of file copy.c.

231 {
233 
234  if (Operation == CcOperationZero)
235  {
236  /* Zero */
238  }
239  else
240  {
241  _SEH2_TRY
242  {
245  else
247  }
249  {
251  }
252  _SEH2_END;
253  }
254  return Status;
255 }
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
LONG NTSTATUS
Definition: precomp.h:26
_SEH2_TRY
Definition: create.c:4250
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
Definition: bufpool.h:45
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
Status
Definition: gdiplustypes.h:24
_SEH2_END
Definition: create.c:4424
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
_In_ FLT_SET_CONTEXT_OPERATION Operation
Definition: fltkernel.h:1468
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
return STATUS_SUCCESS
Definition: btrfs.c:2725

Referenced by CcCopyData().

Variable Documentation

◆ CcDataFlushes

ULONG CcDataFlushes = 0

Definition at line 51 of file copy.c.

Referenced by IoSynchronousPageWrite(), and QSI_DEF().

◆ CcDataPages

ULONG CcDataPages = 0

Definition at line 50 of file copy.c.

Referenced by IoSynchronousPageWrite(), and QSI_DEF().

◆ CcFastMdlReadNotPossible

ULONG CcFastMdlReadNotPossible

Definition at line 40 of file copy.c.

◆ CcFastMdlReadWait

ULONG CcFastMdlReadWait

Definition at line 39 of file copy.c.

◆ CcFastReadNotPossible

ULONG CcFastReadNotPossible

Definition at line 41 of file copy.c.

◆ CcFastReadNoWait

ULONG CcFastReadNoWait

Definition at line 43 of file copy.c.

◆ CcFastReadResourceMiss

ULONG CcFastReadResourceMiss

Definition at line 44 of file copy.c.

◆ CcFastReadWait

ULONG CcFastReadWait

Definition at line 42 of file copy.c.

◆ CcRosTraceLevel

ULONG CcRosTraceLevel = 0

Definition at line 38 of file copy.c.

◆ CcZeroPage

PFN_NUMBER CcZeroPage = 0
static

Definition at line 19 of file copy.c.

Referenced by CcInitCacheZeroPage(), and CcZeroData().