257 ULONG InitialFileSize = 0;
258 ULONG InitialValidDataLength = 0;
339 Irp->IoStatus.Information = 0;
430 Irp->IoStatus.Information = 0;
445 if (IrpContext->FatIoContext ==
NULL) {
449 IrpContext->FatIoContext =
456 IrpContext->FatIoContext = &StackFatIoContext;
474 IrpContext->FatIoContext->Wait.Async.ResourceThreadId =
479 IrpContext->FatIoContext->Wait.Async.ResourceThreadId =
480 ((
ULONG_PTR)IrpContext->FatIoContext) | 3;
483 IrpContext->FatIoContext->Wait.Async.RequestedByteCount =
486 IrpContext->FatIoContext->Wait.Async.FileObject =
FileObject;
498 Irp->IoStatus.Information = 0;
528 VBO StartingDirtyVbo;
530 ULONG DirtyByteCount;
531 ULONG CleanByteCount;
539 DebugTrace(0,
Dbg,
"Type of write is Virtual Volume File\n", 0);
592 || ( (DirtyLbo == 0) && (DirtyByteCount >=
ByteCount) ) ) {
595 "No dirty fat sectors in the write range.\n", 0);
601 DirtyVbo = (
VBO)DirtyLbo;
617 StartingDirtyVbo = DirtyVbo;
625 while ( MoreDirtyRuns ) {
639 #pragma prefast( suppress:28931, "needed for debug build" ) 641 DirtyVbo = (
VBO)DirtyLbo;
643 DebugTrace(0,
Dbg,
"Last dirty fat Mcb entry was a hole: corrupt.\n", 0);
646 #pragma prefast( suppress:28159, "things are seriously wrong if we get here" ) 652 DirtyVbo = (
VBO)DirtyLbo;
688 MoreDirtyRuns =
FALSE;
698 DirtyVbo + DirtyByteCount,
703 MoreDirtyRuns =
FALSE;
720 if (DirtyVbo + DirtyByteCount + CleanByteCount >=
723 MoreDirtyRuns =
FALSE;
731 DirtyVbo += DirtyByteCount + CleanByteCount;
745 WriteLength = (DirtyVbo + DirtyByteCount) - StartingDirtyVbo;
778 IoRuns = StackIoRuns;
781 for (Fat = 0; Fat < (
ULONG)
Vcb->Bpb.Fats; Fat++) {
783 IoRuns[Fat].Vbo = StartingDirtyVbo;
784 IoRuns[Fat].Lbo = Fat * BytesPerFat + StartingDirtyVbo;
785 IoRuns[Fat].Offset = StartingDirtyVbo -
StartingVbo;
805 if (IoRuns != StackIoRuns) {
811 #if (NTDDI_VERSION >= NTDDI_WIN8) 844 "Error %X while writing volume file.\n",
845 Irp->IoStatus.Status );
847 RaiseIosb =
Irp->IoStatus;
861 Irp->IoStatus = RaiseIosb;
896 (
Vcb->Bpb.Sectors != 0 ?
Vcb->Bpb.Sectors :
897 Vcb->Bpb.LargeSectors));
899 StartingLbo = StartingByte.
QuadPart;
921 if (!WriteToEof && (StartingLbo < VolumeSize)) {
991 FatPurgeReferencedFileObjects( IrpContext,
Vcb->RootDcb,
Flush );
1013 if (WriteToEof || StartingLbo >= VolumeSize) {
1018 if (
ByteCount > VolumeSize - StartingLbo) {
1029 IrpContext->FatIoContext->Wait.Async.RequestedByteCount =
1042 StartingLbo = VolumeSize;
1071 #if (NTDDI_VERSION >= NTDDI_WIN8) 1097 IrpContext->FatIoContext =
NULL;
1101 DebugTrace(-1,
Dbg,
"FatNonCachedIo -> STATUS_PENDING\n", 0);
1125 if (SynchronousIo && !PagingIo) {
1127 StartingLbo +
Irp->IoStatus.Information;
1155 ULONG ValidDataLength;
1156 ULONG ValidDataToDisk;
1157 ULONG ValidDataToCheck;
1171 if (NonCachedIo && !PagingIo &&
1180 if (!FatAcquireExclusiveFcb( IrpContext,
FcbOrDcb )) {
1187 FcbOrDcbAcquired =
TRUE;
1188 FcbAcquiredExclusive =
TRUE;
1196 #if (NTDDI_VERSION >= NTDDI_WIN7) 1202 PagingIoResourceAcquired =
TRUE;
1243 PagingIoResourceAcquired =
TRUE;
1294 FcbCanDemoteToShared =
TRUE;
1311 PagingIoResourceAcquired =
TRUE;
1315 IrpContext->FatIoContext->Wait.Async.Resource =
1351 if (!
Wait && NonCachedIo) {
1353 if (!FcbOrDcbAcquired &&
1366 IrpContext->FatIoContext->Wait.Async.Resource =
FcbOrDcb->
Header.Resource;
1368 if (FcbCanDemoteToShared) {
1370 IrpContext->FatIoContext->Wait.Async.Resource2 =
FcbOrDcb->
Header.PagingIoResource;
1374 if (!FcbOrDcbAcquired &&
1375 !FatAcquireSharedFcb( IrpContext,
FcbOrDcb )) {
1382 FcbOrDcbAcquired =
TRUE;
1419 Irp->IoStatus.Information = 0;
1426 DebugTrace( 0,
Dbg,
"PagingIo extending beyond EOF.\n", 0 );
1439 CalledByLazyWriter =
TRUE;
1505 RecursiveWriteThrough =
TRUE;
1543 if ( !CalledByLazyWriter &&
1545 !RecursiveWriteThrough &&
1570 SwitchBackToAsync =
TRUE;
1603 PagingIoResourceAcquired =
FALSE;
1612 if (!FcbAcquiredExclusive) {
1615 FcbOrDcbAcquired =
FALSE;
1617 if (!FatAcquireExclusiveFcb( IrpContext,
FcbOrDcb )) {
1624 FcbOrDcbAcquired =
TRUE;
1627 #pragma prefast( suppress:28931, "convenient for debugging" ) 1629 FcbAcquiredExclusive =
TRUE;
1642 if (SwitchBackToAsync) {
1654 SwitchBackToAsync =
FALSE;
1681 UnwindOutstandingAsync =
TRUE;
1705 Irp->IoStatus.Information = 0;
1721 if (NonCachedIo && !
Wait) {
1723 IrpContext->FatIoContext->Wait.Async.RequestedByteCount =
1734 InitialValidDataLength = ValidDataLength;
1740 FatVerifyFcb( IrpContext,
FcbOrDcb );
1761 Irp->IoStatus.Information = 0;
1787 OplockPostIrp =
TRUE;
1822 ExtendingFile =
TRUE;
1825 if ( ExtendingFile ) {
1851 FatLookupFileAllocationSize( IrpContext,
FcbOrDcb );
1876 ULONG BytesPerCluster;
1877 ULONG ClusterAlignedFileSize;
1915 BytesPerCluster = 1 <<
Vcb->AllocationSupport.LogOfBytesPerCluster;
1924 ClusterAlignedFileSize = ((
FileSize) + (BytesPerCluster - 1)) &
1925 ~(BytesPerCluster - 1);
1928 if (ClusterAlignedFileSize != 0) {
1941 Multiplier = ((
Vcb->AllocationSupport.NumberOfFreeClusters *
1942 (BytesPerCluster >> 5)) /
1943 (ClusterAlignedFileSize -
1946 if (Multiplier > 32) { Multiplier = 32; }
1950 AddedAllocation = Multiplier * (ClusterAlignedFileSize -
FcbOrDcb->
Header.AllocationSize.LowPart);
1952 TargetAllocation =
FcbOrDcb->
Header.AllocationSize.LowPart + AddedAllocation;
1960 if (TargetAllocation > ~BytesPerCluster + 1) {
1962 TargetAllocation = ~BytesPerCluster + 1;
1963 AddedAllocation = TargetAllocation -
FcbOrDcb->
Header.AllocationSize.LowPart;
1973 ApproximateClusterCount = (AddedAllocation / BytesPerCluster);
1975 if (ApproximateClusterCount <= Vcb->AllocationSupport.NumberOfFreeClusters) {
1979 FatAddFileAllocation( IrpContext,
1982 (
ULONG)TargetAllocation );
1984 AllocateMinimumSize =
FALSE;
1996 if ( AllocateMinimumSize ) {
1999 FatAddFileAllocation( IrpContext,
2041 if ( !CalledByLazyWriter &&
2042 !RecursiveWriteThrough &&
2045 ExtendingValidData =
TRUE;
2062 if (FcbCanDemoteToShared) {
2066 FcbAcquiredExclusive =
FALSE;
2070 if (ValidDataToDisk > ValidDataLength) {
2072 ValidDataToCheck = ValidDataToDisk;
2076 ValidDataToCheck = ValidDataLength;
2085 if ( NonCachedIo ) {
2121 DebugTrace( 0,
Dbg,
"FatCommonWrite -> STATUS_NOT_IMPLEMENTED\n", 0);
2144 if (!CalledByLazyWriter &&
2145 !RecursiveWriteThrough &&
2161 WriteFileSizeToDirent =
TRUE;
2167 if (SwitchBackToAsync) {
2173 #ifdef SYSCACHE_COMPILE 2175 #define MY_SIZE 0x1000000 2176 #define LONGMAP_COUNTER 2186 if (
NULL == WriteMask) {
2201 if (Off +
Len > MY_SIZE) {
2202 Len = MY_SIZE - Off;
2219 #ifdef LONGMAP_COUNTER 2246 if (Off +
Len > MY_SIZE) {
2247 Len = MY_SIZE - Off;
2266 if (FatNonCachedIo( IrpContext,
2275 UnwindOutstandingAsync =
FALSE;
2278 #pragma prefast( suppress:28931, "convenient for debugging" ) 2283 IrpContext->FatIoContext =
NULL;
2308 ULONG NewValidDataToDisk;
2315 NT_ASSERT(
Irp->IoStatus.Information == BytesToWrite );
2325 if (NewValidDataToDisk >
FileSize) {
2369 FatLookupFileAllocationSize( IrpContext,
FcbOrDcb );
2374 FatPopUpFileCorrupt( IrpContext,
FcbOrDcb );
2442 &FlushContext->
Dpc );
2464 DebugTrace( 0,
Dbg,
"Cached Write could not wait to zero\n", 0 );
2492 #if (NTDDI_VERSION >= NTDDI_WIN8) 2498 Irp->Tail.Overlay.Thread )) {
2562 FatVerifyFcb( IrpContext,
FcbOrDcb );
2577 PagingIoResourceAcquired =
TRUE;
2581 IrpContext->FatIoContext->Wait.Async.Resource =
2617 #pragma prefast( suppress:28931, "needed for debug build" ) 2638 DebugTrace( 0,
Dbg,
"PagingIo dirent started beyond EOF.\n", 0 );
2640 Irp->IoStatus.Information = 0;
2647 DebugTrace( 0,
Dbg,
"PagingIo dirent extending beyond EOF.\n", 0 );
2656 if (FatNonCachedIo( IrpContext,
2664 IrpContext->FatIoContext =
NULL;
2694 DebugTrace( 0,
Dbg,
"FatCommonWrite -> STATUS_INVALID_PARAMETER\n", 0);
2706 #pragma prefast( suppress:28159, "things are seriously wrong if we get here" ) 2722 ULONG ActualBytesWrote;
2724 DebugTrace( 0,
Dbg,
"Completing request with status = %08lx\n",
2728 Irp->IoStatus.Information);
2734 ActualBytesWrote = (
ULONG)
Irp->IoStatus.Information;
2741 if (SynchronousIo && !PagingIo) {
2771 if ( ExtendingFile && WriteFileSizeToDirent ) {
2788 if ( ExtendingFile && !WriteFileSizeToDirent ) {
2793 if ( ExtendingValidData ) {
2801 if (
FileSize < EndingVboWritten ) {
2841 if (!OplockPostIrp) {
2845 if ( ExtendingFile ) {
2889 if (ExtendingFile || ExtendingValidData) {
2896 FcbOrDcb->
Header.ValidDataLength.LowPart = InitialValidDataLength;
2915 if (UnwindOutstandingAsync) {
2926 if (FcbOrDcbAcquired &&
Irp) {
2931 if (PagingIoResourceAcquired &&
Irp) {
#define READ_AHEAD_GRANULARITY
#define ExGetCurrentResourceThread()
#define FatReleaseVolume(IRPCONTEXT, VCB)
BOOLEAN NTAPI CcPurgeCacheSection(IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN OPTIONAL PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN UninitializeCacheMaps)
#define IRP_CONTEXT_FLAG_WAIT
#define FatNormalizeAndRaiseStatus(IRPCONTEXT, STATUS)
BOOLEAN NTAPI KeSetTimer(IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN PKDPC Dpc OPTIONAL)
PVOID FatMapUserBuffer(IN PIRP_CONTEXT IrpContext, IN OUT PIRP Irp)
#define FCB_LOOKUP_ALLOCATIONSIZE_HINT
PVOID NTAPI FsRtlAllocatePoolWithTag(IN POOL_TYPE PoolType, IN ULONG NumberOfBytes, IN ULONG Tag)
#define PsGetCurrentThread()
VOID NTAPI CcFlushCache(IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN OPTIONAL PLARGE_INTEGER FileOffset, IN ULONG Length, OUT OPTIONAL PIO_STATUS_BLOCK IoStatus)
#define VCB_STATE_FLAG_DEFERRED_FLUSH
FSRTL_ADVANCED_FCB_HEADER Header
CACHE_MANAGER_CALLBACKS CacheManagerCallbacks
#define FatCompleteRequest(IRPCONTEXT, IRP, STATUS)
#define CCB_FLAG_SENT_FORMAT_UNIT
#define STATUS_INVALID_PARAMETER
#define BooleanFlagOn(F, SF)
LOGICAL FatDiskAccountingEnabled
VOID FatAddToWorkque(IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
#define IRP_CONTEXT_FLAG_WRITE_THROUGH
#define IRP_CONTEXT_STACK_IO_CONTEXT
_In_ WDFDPC _In_ BOOLEAN Wait
VOID FatLockUserBuffer(IN PIRP_CONTEXT IrpContext, IN OUT PIRP Irp, IN LOCK_OPERATION Operation, IN ULONG BufferLength)
#define CCB_FLAG_ALLOW_EXTENDED_DASD_IO
BOOLEAN NTAPI FsRtlCheckLockForWriteAccess(IN PFILE_LOCK FileLock, IN PIRP Irp)
VOID FatUnpinRepinnedBcbs(IN PIRP_CONTEXT IrpContext)
#define FatNotifyReportChange(I, V, F, FL, A)
VOID NTAPI ExConvertExclusiveToSharedLite(IN PERESOURCE Resource)
VOID NTAPI FatOplockComplete(IN PVOID Context, IN PIRP Irp)
#define DebugTrace(INDENT, LEVEL, X, Y)
KSPIN_LOCK GeneralSpinLock
#define FILE_NOTIFY_CHANGE_SIZE
SECTION_OBJECT_POINTERS SectionObjectPointers
VOID FatWaitSync(IN PIRP_CONTEXT IrpContext)
CLONG PurgeFailureModeEnableCount
#define FatRaiseStatus(IRPCONTEXT, STATUS)
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
ULONG NTAPI FsRtlNumberOfRunsInLargeMcb(IN PLARGE_MCB Mcb)
#define IRP_CONTEXT_FLAG_DEFERRED_WRITE
#define FO_SYNCHRONOUS_IO
BOOLEAN NTAPI ExAcquireResourceExclusiveLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
#define FO_FILE_SIZE_CHANGED
struct _FCB::@702::@705 Fcb
#define FatReservedBytes(B)
PEPROCESS __stdcall PsGetThreadProcess(_In_ PETHREAD Thread)
FORCEINLINE ULONG KeGetCurrentProcessorNumber(VOID)
#define EXCEPTION_CONTINUE_SEARCH
return STATUS_NOT_IMPLEMENTED
_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN TypeOfOpen
#define STATUS_FILE_CORRUPT_ERROR
VOID NTAPI CcPrepareMdlWrite(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
BOOLEAN FatLookupMcbEntry(IN PVCB Vcb, IN PLARGE_MCB Mcb, IN VBO Vbo, OUT PLBO Lbo, OUT PULONG ByteCount OPTIONAL, OUT PULONG Index OPTIONAL)
VOID(NTAPI * PCC_POST_DEFERRED_WRITE)(_In_ PVOID Context1, _In_ PVOID Context2)
#define FatAcquireExclusiveVolume(IRPCONTEXT, VCB)
#define FatGetFcbOplock(F)
#define CcIsFileCached(FO)
static INLINE BOOLEAN FatIsIoRangeValid(IN PVCB Vcb, IN LARGE_INTEGER Start, IN ULONG Length)
VOID FatRemoveMcbEntry(IN PVCB Vcb, IN PLARGE_MCB Mcb, IN VBO Vbo, IN ULONG SectorCount)
#define FatBugCheck(A, B, C)
#define FatBytesPerFat(B)
#define FILE_ACTION_MODIFIED
#define EXCEPTION_EXECUTE_HANDLER
BOOLEAN NTAPI ExIsResourceAcquiredExclusiveLite(IN PERESOURCE Resource)
#define _SEH2_AbnormalTermination()
VOID NTAPI KeInitializeTimer(OUT PKTIMER Timer)
#define TAG_FAT_IO_CONTEXT
#define FCB_STATE_TRUNCATE_ON_CLOSE
#define IRP_CONTEXT_FLAG_IN_FSP
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
#define FILE_WRITE_TO_END_OF_FILE
union _FCB::@702 Specific
#define IRP_CONTEXT_FLAG_USER_IO
NTSTATUS FatFlushFat(IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
_Acquires_shared_lock_ Fcb FINISHED FatAcquireSharedFcbWaitForEx(IN PIRP_CONTEXT IrpContext, IN PFCB Fcb)
#define CCB_FLAG_COMPLETE_DISMOUNT
#define FatReleaseFcb(IRPCONTEXT, Fcb)
#define FatResetExceptionState(IRPCONTEXT)
#define VCB_STATE_FLAG_LOCKED
#define NT_SUCCESS(StatCode)
BOOLEAN NTAPI CcCanIWrite(IN PFILE_OBJECT FileObject, IN ULONG BytesToWrite, IN BOOLEAN Wait, IN UCHAR Retrying)
#define CcGetFileSizePointer(FO)
PIRP NTAPI IoGetTopLevelIrp(VOID)
NTKERNELAPI VOID NTAPI CcCoherencyFlushAndPurgeCache(_In_ PSECTION_OBJECT_POINTERS SectionObjectPointer, _In_opt_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _Out_ PIO_STATUS_BLOCK IoStatus, _In_opt_ ULONG Flags)
#define STATUS_ACCESS_DENIED
FINISHED FatZeroData(IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN PFILE_OBJECT FileObject, IN ULONG StartingZero, IN ULONG ByteCount)
#define FSRTL_MAX_TOP_LEVEL_IRP_FLAG
#define STATUS_PURGE_FAILED
#define IRP_CONTEXT_FLAG_DISABLE_WRITE_THROUGH
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
#define CCB_FLAG_DASD_FLUSH_DONE
#define TAG_DEFERRED_FLUSH_CONTEXT
enum _TYPE_OF_OPEN TYPE_OF_OPEN
_Must_inspect_result_ _Out_ PLARGE_INTEGER FileSize
_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN PFCB _In_opt_ PCCB Ccb
KDEFERRED_ROUTINE FatDeferredFlushDpc
IN PVCB IN VBO StartingVbo
#define InterlockedExchange
ClearFlag(Dirent->Flags, DIRENT_FLAG_NOT_PERSISTENT)
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS _In_ LARGE_INTEGER ByteCount
BOOLEAN NTAPI CcCopyWrite(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN PVOID Buffer)
BOOLEAN NTAPI ExAcquireSharedStarveExclusive(IN PERESOURCE Resource, IN BOOLEAN Wait)
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
VOID FatInitializeCacheMap(_In_ PFILE_OBJECT FileObject, _In_ PCC_FILE_SIZES FileSizes, _In_ BOOLEAN PinAccess, _In_ PCACHE_MANAGER_CALLBACKS Callbacks, _In_ PVOID LazyWriteContext)
#define VCB_STATE_FLAG_SHUTDOWN
#define CCB_FLAG_DASD_PURGE_DONE
#define KeInitializeEvent(pEvt, foo, foo2)
#define InterlockedIncrement
#define FatIsFastIoPossible(FCB)
PKEVENT OutstandingAsyncEvent
_In_ PIO_STACK_LOCATION IrpSp
VOID NTAPI CcSetFileSizes(IN PFILE_OBJECT FileObject, IN PCC_FILE_SIZES FileSizes)
BOOLEAN NTAPI ExAcquireResourceSharedLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
ULONG NTAPI ExInterlockedAddUlong(IN OUT PULONG Addend, IN ULONG Increment, IN OUT PKSPIN_LOCK Lock)
#define STATUS_FILE_LOCK_CONFLICT
NTSTATUS FatFsdPostRequest(IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
#define ObReferenceObject
__in UCHAR __in POWER_STATE __in_opt PVOID __in PIO_STATUS_BLOCK IoStatus
if(!find_data_address_in_chunk(Vcb, c, length, &address)) return false
#define IRP_CONTEXT_FLAG_RECURSIVE_CALL
#define RtlZeroMemory(Destination, Length)
#define _SEH2_EXCEPT(...)
NTSTATUS NTAPI FsRtlCheckOplock(IN POPLOCK Oplock, IN PIRP Irp, IN PVOID Context, IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine OPTIONAL, IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine OPTIONAL)
#define CollectWriteStats(VCB, OPEN_TYPE, BYTE_COUNT)
#define _SEH2_GetExceptionCode()
VOID FatMultipleAsync(IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN PIRP MasterIrp, IN ULONG MultipleIrpCount, IN PIO_RUN IoRuns)
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
VOID NTAPI KeInitializeDpc(IN PKDPC Dpc, IN PKDEFERRED_ROUTINE DeferredRoutine, IN PVOID DeferredContext)
VOID NTAPI KeClearEvent(IN PKEVENT Event)
#define FSRTL_CACHE_TOP_LEVEL_IRP
#define FatDeleteIrpContext(IRPCONTEXT)
#define IRP_CONTEXT_FLAG_OVERRIDE_VERIFY
VOID NTAPI FatPrePostIrp(IN PVOID Context, IN PIRP Irp)
#define SL_FORCE_DIRECT_WRITE
VOID FatQuickVerifyVcb(IN PIRP_CONTEXT IrpContext, IN PVCB Vcb)
TYPE_OF_OPEN FatDecodeFileObject(_In_ PFILE_OBJECT FileObject, _Outptr_ PVCB *Vcb, _Outptr_ PFCB *FcbOrDcb, _Outptr_ PCCB *Ccb)
#define Int32x32To64(a, b)
#define FSRTL_FLAG_USER_MAPPED_FILE
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)
#define IRP_SYNCHRONOUS_PAGING_IO
VOID FatSingleAsync(IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN LBO Lbo, IN ULONG ByteCount, IN PIRP Irp)
#define DebugDump(STR, LEVEL, PTR)
ULONG OutstandingAsyncWrites
VOID NTAPI CcSetReadAheadGranularity(IN PFILE_OBJECT FileObject, IN ULONG Granularity)