ReactOS 0.4.15-dev-7887-g64a59a1
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_CAN_WRITE_RETRY CC_CAN_WRITE_RETRY
 

Enumerations

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)
 
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)
 
static int CcpCheckInvalidUserBuffer (PEXCEPTION_POINTERS Except, PVOID Buffer, ULONG Length)
 
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 = CC_API_DEBUG
 
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

Enumeration Type Documentation

◆ _CC_CAN_WRITE_RETRY

Enumerator
FirstTry 
RetryAllowRemote 
RetryForceCheckPerFile 
RetryMasterLocked 

Definition at line 23 of file copy.c.

24{
25 FirstTry = 0,
26 RetryAllowRemote = 253,
@ RetryForceCheckPerFile
Definition: copy.c:27
@ FirstTry
Definition: copy.c:25
@ RetryAllowRemote
Definition: copy.c:26
@ RetryMasterLocked
Definition: copy.c:28
enum _CC_CAN_WRITE_RETRY CC_CAN_WRITE_RETRY

Function Documentation

◆ CcCanIWrite()

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

Definition at line 300 of file copy.c.

305{
307 KEVENT WaitEvent;
308 ULONG Length, Pages;
309 BOOLEAN PerFileDefer;
312 CC_CAN_WRITE_RETRY TryContext;
313 PROS_SHARED_CACHE_MAP SharedCacheMap;
314
315 CCTRACE(CC_API_DEBUG, "FileObject=%p BytesToWrite=%lu Wait=%d Retrying=%d\n",
316 FileObject, BytesToWrite, Wait, Retrying);
317
318 /* Write through is always OK */
320 {
321 return TRUE;
322 }
323
324 TryContext = Retrying;
325 /* Allow remote file if not from posted */
327 {
328 return TRUE;
329 }
330
331 /* Don't exceed max tolerated size */
333 if (BytesToWrite < MAX_ZERO_LENGTH)
334 {
335 Length = BytesToWrite;
336 }
337
338 Pages = BYTES_TO_PAGES(Length);
339
340 /* By default, assume limits per file won't be hit */
341 PerFileDefer = FALSE;
342 Fcb = FileObject->FsContext;
343 /* Do we have to check for limits per file? */
344 if (TryContext >= RetryForceCheckPerFile ||
346 {
347 /* If master is not locked, lock it now */
348 if (TryContext != RetryMasterLocked)
349 {
351 }
352
353 /* Let's not assume the file is cached... */
354 if (FileObject->SectionObjectPointer != NULL &&
355 FileObject->SectionObjectPointer->SharedCacheMap != NULL)
356 {
357 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
358 /* Do we have limits per file set? */
359 if (SharedCacheMap->DirtyPageThreshold != 0 &&
360 SharedCacheMap->DirtyPages != 0)
361 {
362 /* Yes, check whether they are blocking */
363 if (Pages + SharedCacheMap->DirtyPages > SharedCacheMap->DirtyPageThreshold)
364 {
365 PerFileDefer = TRUE;
366 }
367 }
368 }
369
370 /* And don't forget to release master */
371 if (TryContext != RetryMasterLocked)
372 {
374 }
375 }
376
377 /* So, now allow write if:
378 * - Not the first try or we have no throttling yet
379 * AND:
380 * - We don't exceed threshold!
381 * - We don't exceed what Mm can allow us to use
382 * + If we're above top, that's fine
383 * + If we're above bottom with limited modified pages, that's fine
384 * + Otherwise, throttle!
385 */
386 if ((TryContext != FirstTry || IsListEmpty(&CcDeferredWrites)) &&
390 !PerFileDefer)
391 {
392 return TRUE;
393 }
394
395 /* If we can wait, we'll start the wait loop for waiting till we can
396 * write for real
397 */
398 if (!Wait)
399 {
400 return FALSE;
401 }
402
403 /* Otherwise, if there are no deferred writes yet, start the lazy writer */
405 {
407
411 }
412
413 /* Initialize our wait event */
415
416 /* And prepare a dummy context */
417 Context.NodeTypeCode = NODE_TYPE_DEFERRED_WRITE;
418 Context.NodeByteSize = sizeof(DEFERRED_WRITE);
419 Context.FileObject = FileObject;
420 Context.BytesToWrite = BytesToWrite;
422 Context.Event = &WaitEvent;
423
424 /* And queue it */
425 if (Retrying)
426 {
427 /* To the top, if that's a retry */
429 &Context.DeferredWriteLinks,
431 }
432 else
433 {
434 /* To the bottom, if that's a first time */
436 &Context.DeferredWriteLinks,
438 }
439
440#if DBG
441 DPRINT1("Actively deferring write for: %p\n", FileObject);
442 DPRINT1("Because:\n");
444 DPRINT1(" There are too many cache dirty pages: %x + %x >= %x\n", CcTotalDirtyPages, Pages, CcDirtyPageThreshold);
446 DPRINT1(" Available pages are below throttle top: %lx <= %lx\n", MmAvailablePages, MmThrottleTop);
447 if (MmModifiedPageListHead.Total >= 1000)
448 DPRINT1(" There are too many modified pages: %lu >= 1000\n", MmModifiedPageListHead.Total);
450 DPRINT1(" Available pages are below throttle bottom: %lx <= %lx\n", MmAvailablePages, MmThrottleBottom);
451#endif
452 /* Now, we'll loop until our event is set. When it is set, it means that caller
453 * can immediately write, and has to
454 */
455 do
456 {
459
460 return TRUE;
461}
unsigned char BOOLEAN
#define DPRINT1
Definition: precomp.h:8
_In_ PFCB Fcb
Definition: cdprocs.h:159
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define BooleanFlagOn(F, SF)
Definition: ext2fs.h:183
#define FSRTL_FLAG_LIMIT_MODIFIED_PAGES
Definition: fsrtltypes.h:47
VOID FASTCALL KeReleaseQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber, IN KIRQL OldIrql)
Definition: spinlock.c:154
KIRQL FASTCALL KeAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
Definition: spinlock.c:108
PLIST_ENTRY NTAPI ExInterlockedInsertHeadList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:114
PLIST_ENTRY NTAPI ExInterlockedInsertTailList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:140
LARGE_INTEGER CcIdleDelay
Definition: lazywrite.c:46
VOID CcScheduleLazyWriteScan(IN BOOLEAN NoDelay)
Definition: lazywrite.c:210
#define KernelMode
Definition: asm.h:34
struct _DEFERRED_WRITE DEFERRED_WRITE
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
@ NotificationEvent
VOID CcPostDeferredWrites(VOID)
Definition: copy.c:73
#define MAX_ZERO_LENGTH
Definition: copy.c:21
KSPIN_LOCK CcDeferredWriteSpinLock
Definition: view.c:58
LIST_ENTRY CcDeferredWrites
Definition: view.c:57
ULONG CcDirtyPageThreshold
Definition: view.c:55
ULONG CcTotalDirtyPages
Definition: view.c:56
#define NODE_TYPE_DEFERRED_WRITE
Definition: cc.h:286
#define CC_API_DEBUG
Definition: cc.h:11
#define CCTRACE(x, fmt,...)
Definition: cc.h:36
ULONG MmThrottleTop
Definition: mminit.c:396
MMPFNLIST MmModifiedPageListHead
Definition: pfnlist.c:45
PFN_NUMBER MmAvailablePages
Definition: freelist.c:26
ULONG MmThrottleBottom
Definition: mminit.c:397
BOOLEAN NTAPI IoIsFileOriginRemote(IN PFILE_OBJECT FileObject)
Definition: file.c:3278
#define STATUS_SUCCESS
Definition: shellext.h:65
ULONG Flags
Definition: ntfs.h:536
PFN_NUMBER Total
Definition: mm.h:443
ULONG DirtyPageThreshold
Definition: cc.h:188
ULONG DirtyPages
Definition: cc.h:180
uint32_t ULONG
Definition: typedefs.h:59
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:550
_In_ WDFDPC _In_ BOOLEAN Wait
Definition: wdfdpc.h:170
#define FO_WRITE_THROUGH
Definition: iotypes.h:1779
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778
@ Executive
Definition: ketypes.h:415
@ LockQueueMasterLock
Definition: ketypes.h:663
#define BYTES_TO_PAGES(Size)

Referenced by CcPostDeferredWrites().

◆ 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 488 of file copy.c.

495{
496 PROS_VACB Vacb;
497 PROS_SHARED_CACHE_MAP SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
499 LONGLONG CurrentOffset;
500 LONGLONG ReadEnd = FileOffset->QuadPart + Length;
501 ULONG ReadLength = 0;
502
503 CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%I64d Length=%lu Wait=%d\n",
504 FileObject, FileOffset->QuadPart, Length, Wait);
505
506 DPRINT("CcCopyRead(FileObject 0x%p, FileOffset %I64x, "
507 "Length %lu, Wait %u, Buffer 0x%p, IoStatus 0x%p)\n",
508 FileObject, FileOffset->QuadPart, Length, Wait,
510
511 if (!SharedCacheMap)
512 return FALSE;
513
514 /* Documented to ASSERT, but KMTests test this case... */
515 // ASSERT((FileOffset->QuadPart + Length) <= SharedCacheMap->FileSize.QuadPart);
516
517 CurrentOffset = FileOffset->QuadPart;
518 while(CurrentOffset < ReadEnd)
519 {
520 Status = CcRosGetVacb(SharedCacheMap, CurrentOffset, &Vacb);
521 if (!NT_SUCCESS(Status))
522 {
524 return FALSE;
525 }
526
528 {
529 ULONG VacbOffset = CurrentOffset % VACB_MAPPING_GRANULARITY;
530 ULONG VacbLength = min(Length, VACB_MAPPING_GRANULARITY - VacbOffset);
531 SIZE_T CopyLength = VacbLength;
532
533 if (!CcRosEnsureVacbResident(Vacb, Wait, FALSE, VacbOffset, VacbLength))
534 return FALSE;
535
537 {
538 RtlCopyMemory(Buffer, (PUCHAR)Vacb->BaseAddress + VacbOffset, CopyLength);
539 }
541 {
543 }
544 _SEH2_END;
545
546 ReadLength += VacbLength;
547
548 Buffer = (PVOID)((ULONG_PTR)Buffer + VacbLength);
549 CurrentOffset += VacbLength;
550 Length -= VacbLength;
551 }
553 {
554 CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
555 }
556 _SEH2_END;
557 }
558
559 IoStatus->Status = STATUS_SUCCESS;
560 IoStatus->Information = ReadLength;
561
562#if 0
563 /* If that was a successful sync read operation, let's handle read ahead */
564 if (Length == 0 && Wait)
565 {
566 PPRIVATE_CACHE_MAP PrivateCacheMap = FileObject->PrivateCacheMap;
567
568 /* If file isn't random access and next read may get us cross VACB boundary,
569 * schedule next read
570 */
572 (CurrentOffset - 1) / VACB_MAPPING_GRANULARITY != (CurrentOffset + ReadLength - 1) / VACB_MAPPING_GRANULARITY)
573 {
575 }
576
577 /* And update read history in private cache map */
578 PrivateCacheMap->FileOffset1.QuadPart = PrivateCacheMap->FileOffset2.QuadPart;
579 PrivateCacheMap->BeyondLastByte1.QuadPart = PrivateCacheMap->BeyondLastByte2.QuadPart;
580 PrivateCacheMap->FileOffset2.QuadPart = FileOffset->QuadPart;
581 PrivateCacheMap->BeyondLastByte2.QuadPart = FileOffset->QuadPart + ReadLength;
582 }
583#endif
584
585 return TRUE;
586}
ULONG ReadLength
LONG NTSTATUS
Definition: precomp.h:26
VOID NTAPI CcScheduleReadAhead(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length)
Definition: cachesub.c:92
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:160
Definition: bufpool.h:45
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define _SEH2_FINALLY
Definition: filesup.c:21
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
Status
Definition: gdiplustypes.h:25
#define min(a, b)
Definition: monoChain.cc:55
__in UCHAR __in POWER_STATE __in_opt PVOID __in PIO_STATUS_BLOCK IoStatus
Definition: mxum.h:159
static int CcpCheckInvalidUserBuffer(PEXCEPTION_POINTERS Except, PVOID Buffer, ULONG Length)
Definition: copy.c:465
NTSTATUS CcRosReleaseVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, PROS_VACB Vacb, BOOLEAN Dirty, BOOLEAN Mapped)
Definition: view.c:574
BOOLEAN CcRosEnsureVacbResident(_In_ PROS_VACB Vacb, _In_ BOOLEAN Wait, _In_ BOOLEAN NoRead, _In_ ULONG Offset, _In_ ULONG Length)
Definition: view.c:910
NTSTATUS CcRosGetVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset, PROS_VACB *Vacb)
Definition: view.c:957
#define ExRaiseStatus
Definition: ntoskrnl.h:114
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#define _SEH2_GetExceptionInformation()
Definition: pseh2_64.h:158
#define DPRINT
Definition: sndvol32.h:71
LARGE_INTEGER BeyondLastByte1
Definition: cctypes.h:78
LARGE_INTEGER FileOffset2
Definition: cctypes.h:79
LARGE_INTEGER FileOffset1
Definition: cctypes.h:77
LARGE_INTEGER BeyondLastByte2
Definition: cctypes.h:80
Definition: cc.h:207
PVOID BaseAddress
Definition: cc.h:209
int64_t LONGLONG
Definition: typedefs.h:68
void * PVOID
Definition: typedefs.h:50
ULONG_PTR SIZE_T
Definition: typedefs.h:80
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * PUCHAR
Definition: typedefs.h:53
#define STATUS_INVALID_USER_BUFFER
Definition: udferr_usr.h:166
LONGLONG QuadPart
Definition: typedefs.h:114
#define VACB_MAPPING_GRANULARITY
#define FO_RANDOM_ACCESS
Definition: iotypes.h:1796

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 593 of file copy.c.

599{
600 PROS_VACB Vacb;
601 PROS_SHARED_CACHE_MAP SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
603 LONGLONG CurrentOffset;
604 LONGLONG WriteEnd;
605
606 CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%I64d Length=%lu Wait=%d Buffer=%p\n",
607 FileObject, FileOffset->QuadPart, Length, Wait, Buffer);
608
609 DPRINT("CcCopyWrite(FileObject 0x%p, FileOffset %I64x, "
610 "Length %lu, Wait %u, Buffer 0x%p)\n",
611 FileObject, FileOffset->QuadPart, Length, Wait, Buffer);
612
613 if (!SharedCacheMap)
614 return FALSE;
615
616 Status = RtlLongLongAdd(FileOffset->QuadPart, Length, &WriteEnd);
617 if (!NT_SUCCESS(Status))
619
620 ASSERT(WriteEnd <= SharedCacheMap->SectionSize.QuadPart);
621
622 CurrentOffset = FileOffset->QuadPart;
623 while(CurrentOffset < WriteEnd)
624 {
625 ULONG VacbOffset = CurrentOffset % VACB_MAPPING_GRANULARITY;
626 ULONG VacbLength = min(WriteEnd - CurrentOffset, VACB_MAPPING_GRANULARITY - VacbOffset);
627
628 Status = CcRosGetVacb(SharedCacheMap, CurrentOffset, &Vacb);
629 if (!NT_SUCCESS(Status))
630 {
632 return FALSE;
633 }
634
636 {
637 if (!CcRosEnsureVacbResident(Vacb, Wait, FALSE, VacbOffset, VacbLength))
638 {
639 return FALSE;
640 }
641
643 {
644 RtlCopyMemory((PVOID)((ULONG_PTR)Vacb->BaseAddress + VacbOffset), Buffer, VacbLength);
645 }
647 {
649 }
650 _SEH2_END;
651
652 Buffer = (PVOID)((ULONG_PTR)Buffer + VacbLength);
653 CurrentOffset += VacbLength;
654
655 /* Tell Mm */
656 Status = MmMakePagesDirty(NULL, Add2Ptr(Vacb->BaseAddress, VacbOffset), VacbLength);
657 if (!NT_SUCCESS(Status))
659 }
661 {
662 /* Do not mark the VACB as dirty if an exception was raised */
663 CcRosReleaseVacb(SharedCacheMap, Vacb, !_SEH2_AbnormalTermination(), FALSE);
664 }
665 _SEH2_END;
666 }
667
668 /* Flush if needed */
669 if (FileObject->Flags & FO_WRITE_THROUGH)
670 CcFlushCache(FileObject->SectionObjectPointer, FileOffset, Length, NULL);
671
672 return TRUE;
673}
VOID NTAPI CcFlushCache(IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN OPTIONAL PLARGE_INTEGER FileOffset, IN ULONG Length, OUT OPTIONAL PIO_STATUS_BLOCK IoStatus)
Definition: cachesub.c:222
#define Add2Ptr(PTR, INC)
#define ASSERT(a)
Definition: mode.c:44
NTSTATUS NTAPI MmMakePagesDirty(_In_ PEPROCESS Process, _In_ PVOID Address, _In_ ULONG Length)
Definition: section.c:5202
#define _SEH2_AbnormalTermination()
Definition: pseh2_64.h:160

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 680 of file copy.c.

687{
691
692 CCTRACE(CC_API_DEBUG, "FileObject=%p PostRoutine=%p Context1=%p Context2=%p BytesToWrite=%lu Retrying=%d\n",
693 FileObject, PostRoutine, Context1, Context2, BytesToWrite, Retrying);
694
695 /* Try to allocate a context for queueing the write operation */
697 /* If it failed, immediately execute the operation! */
698 if (Context == NULL)
699 {
700 PostRoutine(Context1, Context2);
701 return;
702 }
703
704 Fcb = FileObject->FsContext;
705
706 /* Otherwise, initialize the context */
708 Context->NodeTypeCode = NODE_TYPE_DEFERRED_WRITE;
709 Context->NodeByteSize = sizeof(DEFERRED_WRITE);
710 Context->FileObject = FileObject;
711 Context->PostRoutine = PostRoutine;
712 Context->Context1 = Context1;
713 Context->Context2 = Context2;
714 Context->BytesToWrite = BytesToWrite;
716
717 /* And queue it */
718 if (Retrying)
719 {
720 /* To the top, if that's a retry */
722 &Context->DeferredWriteLinks,
724 }
725 else
726 {
727 /* To the bottom, if that's a first time */
729 &Context->DeferredWriteLinks,
731 }
732
733 /* Try to execute the posted writes */
735
736 /* Schedule a lazy writer run to handle deferred writes */
739 {
741 }
743}
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define NonPagedPool
Definition: env_spec_w32.h:307
LAZY_WRITER LazyWriter
Definition: lazywrite.c:37
BOOLEAN ScanActive
Definition: cc.h:246
_In_ PNET_PNP_EVENT _In_ PTDI_PNP_CONTEXT Context1
Definition: tdikrnl.h:1095
_In_ PNET_PNP_EVENT _In_ PTDI_PNP_CONTEXT _In_ PTDI_PNP_CONTEXT Context2
Definition: tdikrnl.h:1096
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262

◆ 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 750 of file copy.c.

757{
758 LARGE_INTEGER LargeFileOffset;
760
761 CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%lu Length=%lu PageCount=%lu Buffer=%p\n",
762 FileObject, FileOffset, Length, PageCount, Buffer);
763
765
766 LargeFileOffset.QuadPart = FileOffset;
768 &LargeFileOffset,
769 Length,
770 TRUE,
771 Buffer,
772 IoStatus);
773 ASSERT(Success == TRUE);
774}
@ Success
Definition: eventcreate.c:712
#define DBG_UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:318
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:488

◆ CcFastCopyWrite()

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

Definition at line 781 of file copy.c.

786{
787 LARGE_INTEGER LargeFileOffset;
789
790 CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%lu Length=%lu Buffer=%p\n",
792
793 LargeFileOffset.QuadPart = FileOffset;
795 &LargeFileOffset,
796 Length,
797 TRUE,
798 Buffer);
799 ASSERT(Success == TRUE);
800}
BOOLEAN NTAPI CcCopyWrite(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN PVOID Buffer)
Definition: copy.c:593

◆ CcInitCacheZeroPage()

VOID NTAPI CcInitCacheZeroPage ( VOID  )

Definition at line 56 of file copy.c.

58{
60
62 //MI_SET_PROCESS2(PsGetCurrentProcess()->ImageFileName);
64 if (!NT_SUCCESS(Status))
65 {
66 DbgPrint("Can't allocate CcZeroPage.\n");
67 KeBugCheck(CACHE_MANAGER);
68 }
70}
DECLSPEC_NORETURN VOID NTAPI KeBugCheck(ULONG BugCheckCode)
Definition: bug.c:1431
#define DbgPrint
Definition: hal.h:12
VOID NTAPI MiZeroPhysicalPage(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:122
static PFN_NUMBER CcZeroPage
Definition: copy.c:19
@ MI_USAGE_CACHE
Definition: mm.h:342
#define MC_SYSTEM
Definition: mm.h:115
#define MI_SET_USAGE(x)
Definition: mm.h:317
NTSTATUS NTAPI MmRequestPageMemoryConsumer(ULONG Consumer, BOOLEAN MyWait, PPFN_NUMBER AllocatedPage)
Definition: balance.c:313

Referenced by CcInitView().

◆ CcpCheckInvalidUserBuffer()

static int CcpCheckInvalidUserBuffer ( PEXCEPTION_POINTERS  Except,
PVOID  Buffer,
ULONG  Length 
)
static

Definition at line 465 of file copy.c.

466{
467 ULONG_PTR ExceptionAddress;
468 ULONG_PTR BeginAddress = (ULONG_PTR)Buffer;
469 ULONG_PTR EndAddress = (ULONG_PTR)Buffer + Length;
470
473 if (Except->ExceptionRecord->NumberParameters < 2)
475
476 ExceptionAddress = Except->ExceptionRecord->ExceptionInformation[1];
477 if ((ExceptionAddress >= BeginAddress) && (ExceptionAddress < EndAddress))
479
481}
#define ULONG_PTR
Definition: config.h:101
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define EXCEPTION_CONTINUE_SEARCH
Definition: excpt.h:86
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
PEXCEPTION_RECORD ExceptionRecord
Definition: rtltypes.h:200
DWORD ExceptionCode
Definition: compat.h:208
DWORD NumberParameters
Definition: compat.h:212
ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]
Definition: compat.h:213

Referenced by CcCopyRead(), and CcCopyWrite().

◆ CcPerformReadAhead()

VOID CcPerformReadAhead ( IN PFILE_OBJECT  FileObject)

Definition at line 130 of file copy.c.

132{
134 LONGLONG CurrentOffset;
136 PROS_SHARED_CACHE_MAP SharedCacheMap;
137 PROS_VACB Vacb;
138 ULONG PartialLength;
140 PPRIVATE_CACHE_MAP PrivateCacheMap;
143
144 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
145
146 /* Critical:
147 * PrivateCacheMap might disappear in-between if the handle
148 * to the file is closed (private is attached to the handle not to
149 * the file), so we need to lock the master lock while we deal with
150 * it. It won't disappear without attempting to lock such lock.
151 */
153 PrivateCacheMap = FileObject->PrivateCacheMap;
154 /* If the handle was closed since the read ahead was scheduled, just quit */
155 if (PrivateCacheMap == NULL)
156 {
159 return;
160 }
161 /* Otherwise, extract read offset and length and release private map */
162 else
163 {
165 CurrentOffset = PrivateCacheMap->ReadAheadOffset[1].QuadPart;
166 Length = PrivateCacheMap->ReadAheadLength[1];
168 }
170
171 /* Time to go! */
172 DPRINT("Doing ReadAhead for %p\n", FileObject);
173 /* Lock the file, first */
174 if (!SharedCacheMap->Callbacks->AcquireForReadAhead(SharedCacheMap->LazyWriteContext, FALSE))
175 {
176 Locked = FALSE;
177 goto Clear;
178 }
179
180 /* Remember it's locked */
181 Locked = TRUE;
182
183 /* Don't read past the end of the file */
184 if (CurrentOffset >= SharedCacheMap->FileSize.QuadPart)
185 {
186 goto Clear;
187 }
188 if (CurrentOffset + Length > SharedCacheMap->FileSize.QuadPart)
189 {
190 Length = SharedCacheMap->FileSize.QuadPart - CurrentOffset;
191 }
192
193 /* Next of the algorithm will lock like CcCopyData with the slight
194 * difference that we don't copy data back to an user-backed buffer
195 * We just bring data into Cc
196 */
197 PartialLength = CurrentOffset % VACB_MAPPING_GRANULARITY;
198 if (PartialLength != 0)
199 {
200 PartialLength = min(Length, VACB_MAPPING_GRANULARITY - PartialLength);
201 Status = CcRosRequestVacb(SharedCacheMap,
202 ROUND_DOWN(CurrentOffset, VACB_MAPPING_GRANULARITY),
203 &Vacb);
204 if (!NT_SUCCESS(Status))
205 {
206 DPRINT1("Failed to request VACB: %lx!\n", Status);
207 goto Clear;
208 }
209
211 {
213 CurrentOffset % VACB_MAPPING_GRANULARITY, PartialLength);
214 }
216 {
217 Success = FALSE;
218 }
220
221 if (!Success)
222 {
223 CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
224 DPRINT1("Failed to read data: %lx!\n", Status);
225 goto Clear;
226 }
227
228 CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
229
230 Length -= PartialLength;
231 CurrentOffset += PartialLength;
232 }
233
234 while (Length > 0)
235 {
236 ASSERT(CurrentOffset % VACB_MAPPING_GRANULARITY == 0);
237 PartialLength = min(VACB_MAPPING_GRANULARITY, Length);
238 Status = CcRosRequestVacb(SharedCacheMap,
239 CurrentOffset,
240 &Vacb);
241 if (!NT_SUCCESS(Status))
242 {
243 DPRINT1("Failed to request VACB: %lx!\n", Status);
244 goto Clear;
245 }
246
248 {
249 Success = CcRosEnsureVacbResident(Vacb, TRUE, FALSE, 0, PartialLength);
250 }
252 {
253 Success = FALSE;
254 }
256
257 if (!Success)
258 {
259 CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
260 DPRINT1("Failed to read data: %lx!\n", Status);
261 goto Clear;
262 }
263
264 CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE);
265
266 Length -= PartialLength;
267 CurrentOffset += PartialLength;
268 }
269
270Clear:
271 /* See previous comment about private cache map */
273 PrivateCacheMap = FileObject->PrivateCacheMap;
274 if (PrivateCacheMap != NULL)
275 {
276 /* Mark read ahead as unactive */
278 InterlockedAnd((volatile long *)&PrivateCacheMap->UlongFlags, ~PRIVATE_CACHE_MAP_READ_AHEAD_ACTIVE);
280 }
282
283 /* If file was locked, release it */
284 if (Locked)
285 {
286 SharedCacheMap->Callbacks->ReleaseFromReadAhead(SharedCacheMap->LazyWriteContext);
287 }
288
289 /* And drop our extra reference (See: CcScheduleReadAhead) */
291
292 return;
293}
#define ROUND_DOWN(n, align)
Definition: eventvwr.h:33
#define InterlockedAnd
Definition: interlocked.h:62
static void Clear(void)
Definition: treeview.c:386
#define PRIVATE_CACHE_MAP_READ_AHEAD_ACTIVE
Definition: cctypes.h:64
_In_ PMEMORY_AREA _In_ PVOID _In_ BOOLEAN Locked
Definition: newmm.h:209
NTSTATUS CcRosRequestVacb(PROS_SHARED_CACHE_MAP SharedCacheMap, LONGLONG FileOffset, PROS_VACB *Vacb)
Definition: view.c:1008
#define KeAcquireSpinLockAtDpcLevel(SpinLock)
Definition: ke.h:125
#define KeReleaseSpinLockFromDpcLevel(SpinLock)
Definition: ke.h:135
PACQUIRE_FOR_READ_AHEAD AcquireForReadAhead
Definition: cctypes.h:41
PRELEASE_FROM_READ_AHEAD ReleaseFromReadAhead
Definition: cctypes.h:42
ULONG ReadAheadLength[2]
Definition: cctypes.h:82
LARGE_INTEGER ReadAheadOffset[2]
Definition: cctypes.h:81
KSPIN_LOCK ReadAheadSpinLock
Definition: cctypes.h:83
ULONG UlongFlags
Definition: cctypes.h:73
LARGE_INTEGER FileSize
Definition: cc.h:175
PCACHE_MANAGER_CALLBACKS Callbacks
Definition: cc.h:185
PVOID LazyWriteContext
Definition: cc.h:186
#define ObDereferenceObject
Definition: obfuncs.h:203

Referenced by CcWorkerThread().

◆ CcPostDeferredWrites()

VOID CcPostDeferredWrites ( VOID  )

Definition at line 73 of file copy.c.

74{
75 LIST_ENTRY ToInsertBack;
76
77 InitializeListHead(&ToInsertBack);
78
79 /* We'll try to write as much as we can */
80 while (TRUE)
81 {
82 PDEFERRED_WRITE DeferredWrite;
83 PLIST_ENTRY ListEntry;
84
85 DeferredWrite = NULL;
86
88
89 if (!ListEntry)
90 break;
91
92 DeferredWrite = CONTAINING_RECORD(ListEntry, DEFERRED_WRITE, DeferredWriteLinks);
93
94 /* Check if we can write */
95 if (CcCanIWrite(DeferredWrite->FileObject, DeferredWrite->BytesToWrite, FALSE, RetryForceCheckPerFile))
96 {
97 /* If we have an event, set it and go along */
98 if (DeferredWrite->Event)
99 {
100 KeSetEvent(DeferredWrite->Event, IO_NO_INCREMENT, FALSE);
101 }
102 /* Otherwise, call the write routine and free the context */
103 else
104 {
105 DeferredWrite->PostRoutine(DeferredWrite->Context1, DeferredWrite->Context2);
106 ExFreePoolWithTag(DeferredWrite, 'CcDw');
107 }
108 continue;
109 }
110
111 /* Keep it for later */
112 InsertHeadList(&ToInsertBack, &DeferredWrite->DeferredWriteLinks);
113
114 /* If we don't accept modified pages, stop here */
115 if (!DeferredWrite->LimitModifiedPages)
116 {
117 break;
118 }
119 }
120
121 /* Insert what we couldn't write back in the list */
122 while (!IsListEmpty(&ToInsertBack))
123 {
124 PLIST_ENTRY ListEntry = RemoveTailList(&ToInsertBack);
126 }
127}
#define InsertHeadList(ListHead, Entry)
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
#define RemoveTailList(ListHead)
Definition: env_spec_w32.h:975
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
PLIST_ENTRY NTAPI ExInterlockedRemoveHeadList(IN OUT PLIST_ENTRY ListHead, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:166
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
BOOLEAN NTAPI CcCanIWrite(IN PFILE_OBJECT FileObject, IN ULONG BytesToWrite, IN BOOLEAN Wait, IN BOOLEAN Retrying)
Definition: copy.c:300
PCC_POST_DEFERRED_WRITE PostRoutine
Definition: cctypes.h:175
PKEVENT Event
Definition: cctypes.h:174
ULONG BytesToWrite
Definition: cctypes.h:172
BOOLEAN LimitModifiedPages
Definition: cctypes.h:178
PVOID Context1
Definition: cctypes.h:176
PFILE_OBJECT FileObject
Definition: cctypes.h:171
PVOID Context2
Definition: cctypes.h:177
LIST_ENTRY DeferredWriteLinks
Definition: cctypes.h:173
Definition: typedefs.h:120
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
#define IO_NO_INCREMENT
Definition: iotypes.h:598

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

◆ CcZeroData()

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

Definition at line 807 of file copy.c.

812{
816 PROS_VACB Vacb;
817 PROS_SHARED_CACHE_MAP SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
818
819 CCTRACE(CC_API_DEBUG, "FileObject=%p StartOffset=%I64u EndOffset=%I64u Wait=%d\n",
820 FileObject, StartOffset->QuadPart, EndOffset->QuadPart, Wait);
821
822 DPRINT("CcZeroData(FileObject 0x%p, StartOffset %I64x, EndOffset %I64x, "
823 "Wait %u)\n", FileObject, StartOffset->QuadPart, EndOffset->QuadPart,
824 Wait);
825
826 Length = EndOffset->QuadPart - StartOffset->QuadPart;
827 WriteOffset.QuadPart = StartOffset->QuadPart;
828
829 if (!SharedCacheMap)
830 {
831 /* Make this a non-cached write */
834 PMDL Mdl;
835 ULONG i;
836 ULONG CurrentLength;
837 PPFN_NUMBER PfnArray;
838
839 /* Setup our Mdl */
841 if (!Mdl)
843
844 PfnArray = MmGetMdlPfnArray(Mdl);
845 for (i = 0; i < BYTES_TO_PAGES(Mdl->ByteCount); i++)
846 PfnArray[i] = CcZeroPage;
847 Mdl->MdlFlags |= MDL_PAGES_LOCKED;
848
849 /* Perform the write sequencially */
850 while (Length > 0)
851 {
852 CurrentLength = min(Length, MAX_ZERO_LENGTH);
853
854 Mdl->ByteCount = CurrentLength;
855
858 if (Status == STATUS_PENDING)
859 {
861 Status = Iosb.Status;
862 }
863 if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
864 {
865 MmUnmapLockedPages(Mdl->MappedSystemVa, Mdl);
866 }
867 if (!NT_SUCCESS(Status))
868 {
869 IoFreeMdl(Mdl);
871 }
872 WriteOffset.QuadPart += CurrentLength;
873 Length -= CurrentLength;
874 }
875
876 IoFreeMdl(Mdl);
877
878 return TRUE;
879 }
880
881 /* See if we should simply truncate the valid data length */
882 if ((StartOffset->QuadPart < SharedCacheMap->ValidDataLength.QuadPart) && (EndOffset->QuadPart >= SharedCacheMap->ValidDataLength.QuadPart))
883 {
884 DPRINT1("Truncating VDL.\n");
885 SharedCacheMap->ValidDataLength = *StartOffset;
886 return TRUE;
887 }
888
889 ASSERT(EndOffset->QuadPart <= SharedCacheMap->SectionSize.QuadPart);
890
891 while(WriteOffset.QuadPart < EndOffset->QuadPart)
892 {
893 ULONG VacbOffset = WriteOffset.QuadPart % VACB_MAPPING_GRANULARITY;
894 ULONG VacbLength = min(Length, VACB_MAPPING_GRANULARITY - VacbOffset);
895
896 Status = CcRosGetVacb(SharedCacheMap, WriteOffset.QuadPart, &Vacb);
897 if (!NT_SUCCESS(Status))
898 {
900 return FALSE;
901 }
902
904 {
905 if (!CcRosEnsureVacbResident(Vacb, Wait, FALSE, VacbOffset, VacbLength))
906 {
907 return FALSE;
908 }
909
910 RtlZeroMemory((PVOID)((ULONG_PTR)Vacb->BaseAddress + VacbOffset), VacbLength);
911
912 WriteOffset.QuadPart += VacbLength;
913 Length -= VacbLength;
914
915 /* Tell Mm */
916 Status = MmMakePagesDirty(NULL, Add2Ptr(Vacb->BaseAddress, VacbOffset), VacbLength);
917 if (!NT_SUCCESS(Status))
919 }
921 {
922 /* Do not mark the VACB as dirty if an exception was raised */
923 CcRosReleaseVacb(SharedCacheMap, Vacb, !_SEH2_AbnormalTermination(), FALSE);
924 }
925 _SEH2_END;
926 }
927
928 /* Flush if needed */
929 if (FileObject->Flags & FO_WRITE_THROUGH)
930 CcFlushCache(FileObject->SectionObjectPointer, StartOffset, EndOffset->QuadPart - StartOffset->QuadPart, NULL);
931
932 return TRUE;
933}
return Iosb
Definition: create.c:4402
#define IoFreeMdl
Definition: fxmdl.h:89
#define IoAllocateMdl
Definition: fxmdl.h:88
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
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:1146
VOID NTAPI MmUnmapLockedPages(IN PVOID BaseAddress, IN PMDL Mdl)
Definition: mdlsup.c:837
#define STATUS_PENDING
Definition: ntstatus.h:82
ULONG * PPFN_NUMBER
Definition: ke.h:9
LARGE_INTEGER ValidDataLength
Definition: cc.h:178
LARGE_INTEGER SectionSize
Definition: cc.h:177
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_In_ WDFDEVICE _In_ PVOID _In_opt_ PMDL Mdl
_Must_inspect_result_ _In_ WDFUSBPIPE _In_ WDFREQUEST _In_opt_ WDFMEMORY _In_opt_ PWDFMEMORY_OFFSET WriteOffset
Definition: wdfusb.h:1921
#define MmGetMdlPfnArray(_Mdl)
#define MDL_PAGES_LOCKED
Definition: mmtypes.h:19
#define MDL_MAPPED_TO_SYSTEM_VA
Definition: mmtypes.h:18

◆ MiZeroPhysicalPage()

VOID NTAPI MiZeroPhysicalPage ( IN PFN_NUMBER  PageFrameIndex)

Definition at line 122 of file pfnlist.c.

123{
127
128 /* Map in hyperspace, then wipe it using XMMI or MEMSET */
133}
#define PAGE_SIZE
Definition: env_spec_w32.h:49
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
VOID FASTCALL KeZeroPages(IN PVOID Address, IN ULONG Size)
Definition: cpu.c:56
VOID NTAPI MiUnmapPageInHyperSpace(IN PEPROCESS Process, IN PVOID Address, IN KIRQL OldIrql)
Definition: hypermap.c:91
PVOID NTAPI MiMapPageInHyperSpace(IN PEPROCESS Process, IN PFN_NUMBER Page, IN PKIRQL OldIrql)
Definition: hypermap.c:28
_Must_inspect_result_ _In_ WDFDMATRANSACTION _In_ PFN_WDF_PROGRAM_DMA _In_ WDF_DMA_DIRECTION _In_ PMDL _In_ PVOID VirtualAddress
#define PsGetCurrentProcess
Definition: psfuncs.h:17

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

Variable Documentation

◆ CcDataFlushes

ULONG CcDataFlushes = 0

Definition at line 44 of file copy.c.

Referenced by IoSynchronousPageWrite(), and QSI_DEF().

◆ CcDataPages

ULONG CcDataPages = 0

Definition at line 43 of file copy.c.

Referenced by IoSynchronousPageWrite(), and QSI_DEF().

◆ CcFastMdlReadNotPossible

ULONG CcFastMdlReadNotPossible

Definition at line 33 of file copy.c.

◆ CcFastMdlReadWait

ULONG CcFastMdlReadWait

Definition at line 32 of file copy.c.

◆ CcFastReadNotPossible

ULONG CcFastReadNotPossible

Definition at line 34 of file copy.c.

◆ CcFastReadNoWait

ULONG CcFastReadNoWait

Definition at line 36 of file copy.c.

◆ CcFastReadResourceMiss

ULONG CcFastReadResourceMiss

Definition at line 37 of file copy.c.

◆ CcFastReadWait

ULONG CcFastReadWait

Definition at line 35 of file copy.c.

◆ CcRosTraceLevel

ULONG CcRosTraceLevel = CC_API_DEBUG

Definition at line 31 of file copy.c.

◆ CcZeroPage

PFN_NUMBER CcZeroPage = 0
static

Definition at line 19 of file copy.c.

Referenced by CcInitCacheZeroPage(), and CcZeroData().