deviosup.c File Reference

#include "fatprocs.h"

Include dependency graph for deviosup.c:

Go to the source code of this file.

Classes
struct	_FAT_SYNC_CONTEXT
struct	FAT_PAGING_FILE_CONTEXT

Macros
#define	BugCheckFileId   (FAT_BUG_CHECK_DEVIOSUP)
#define	Dbg   (DEBUG_TRACE_DEVIOSUP)
#define	CollectDiskIoStats(VCB, FUNCTION, IS_USER_IO, COUNT)
#define	FatLowLevelReadWrite(IRPCONTEXT, DO, IRP, VCB)
#define	FatDoCompletionZero(I, C)
#define	FatUpdateIOCountersPCW(IsAWrite, Count)

Typedefs
typedef struct _FAT_SYNC_CONTEXT	FAT_SYNC_CONTEXT
typedef struct _FAT_SYNC_CONTEXT *	PFAT_SYNC_CONTEXT
typedef struct FAT_PAGING_FILE_CONTEXT	FAT_PAGING_FILE_CONTEXT
typedef struct FAT_PAGING_FILE_CONTEXT *	PFAT_PAGING_FILE_CONTEXT

Functions
NTSTATUS NTAPI	FatMultiSyncCompletionRoutine (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Contxt)
NTSTATUS NTAPI	FatMultiAsyncCompletionRoutine (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Contxt)
NTSTATUS NTAPI	FatSpecialSyncCompletionRoutine (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Contxt)
NTSTATUS NTAPI	FatSingleSyncCompletionRoutine (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Contxt)
NTSTATUS NTAPI	FatSingleAsyncCompletionRoutine (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Contxt)
NTSTATUS NTAPI	FatPagingFileCompletionRoutine (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID MasterIrp)
NTSTATUS NTAPI	FatPagingFileCompletionRoutineCatch (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Contxt)
VOID	FatSingleNonAlignedSync (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN PUCHAR Buffer, IN LBO Lbo, IN ULONG ByteCount, IN PIRP Irp)
VOID	FatPagingFileIo (IN PIRP Irp, IN PFCB Fcb)
VOID	FatUpdateDiskStats (IN PIRP_CONTEXT IrpContext, IN PIRP Irp, IN ULONG ByteCount)
	_Requires_lock_held_ (_Global_critical_region_)
VOID	FatMultipleAsync (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN PIRP MasterIrp, IN ULONG MultipleIrpCount, IN PIO_RUN IoRuns)
VOID	FatSingleAsync (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN LBO Lbo, IN ULONG ByteCount, IN PIRP Irp)
VOID	FatWaitSync (IN PIRP_CONTEXT IrpContext)
NTSTATUS	FatPagingFileErrorHandler (IN PIRP Irp, IN PKEVENT Event OPTIONAL)
VOID	FatLockUserBuffer (IN PIRP_CONTEXT IrpContext, IN OUT PIRP Irp, IN LOCK_OPERATION Operation, IN ULONG BufferLength)
PVOID	FatMapUserBuffer (IN PIRP_CONTEXT IrpContext, IN OUT PIRP Irp)
PVOID	FatBufferUserBuffer (IN PIRP_CONTEXT IrpContext, IN OUT PIRP Irp, IN ULONG BufferLength)
NTSTATUS	FatToggleMediaEjectDisable (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN BOOLEAN PreventRemoval)
NTSTATUS	FatPerformDevIoCtrl (IN PIRP_CONTEXT IrpContext, IN ULONG IoControlCode, IN PDEVICE_OBJECT Device, IN PVOID InputBuffer OPTIONAL, IN ULONG InputBufferLength, OUT PVOID OutputBuffer OPTIONAL, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN BOOLEAN OverrideVerify, OUT PIO_STATUS_BLOCK Iosb OPTIONAL)
PMDL	FatBuildZeroMdl (__in PIRP_CONTEXT IrpContext, __in ULONG Length)

Variables
IO_COMPLETION_ROUTINE	FatMultiSyncCompletionRoutine
IO_COMPLETION_ROUTINE	FatMultiAsyncCompletionRoutine
IO_COMPLETION_ROUTINE	FatSpecialSyncCompletionRoutine
IO_COMPLETION_ROUTINE	FatSingleSyncCompletionRoutine
IO_COMPLETION_ROUTINE	FatSingleAsyncCompletionRoutine
IO_COMPLETION_ROUTINE	FatPagingFileCompletionRoutine
IO_COMPLETION_ROUTINE	FatPagingFileCompletionRoutineCatch

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (FAT_BUG_CHECK_DEVIOSUP)

Definition at line 22 of file deviosup.c.

CollectDiskIoStats

#define CollectDiskIoStats	(		VCB,
			FUNCTION,
			IS_USER_IO,
			COUNT
	)

Value:

    {                                    \
    PFILESYSTEM_STATISTICS Stats = &(VCB)->Statistics[KeGetCurrentProcessorNumber() % FatData.NumberProcessors].Common;   \
    if (IS_USER_IO) {                                                                          \
        if ((FUNCTION) == IRP_MJ_WRITE) {                                                      \
            Stats->UserDiskWrites += (COUNT);                                                  \
        } else {                                                                               \
            Stats->UserDiskReads += (COUNT);                                                   \
        }                                                                                      \
    } else {                                                                                   \
        if ((FUNCTION) == IRP_MJ_WRITE) {                                                      \
            Stats->MetaDataDiskWrites += (COUNT);                                              \
        } else {                                                                               \
            Stats->MetaDataDiskReads += (COUNT);                                               \
        }                                                                                      \
    }                                                                                          \
}

Definition at line 30 of file deviosup.c.

Dbg

#define Dbg   (DEBUG_TRACE_DEVIOSUP)

Definition at line 28 of file deviosup.c.

FatDoCompletionZero

#define FatDoCompletionZero	(		I,
			C
	)

Value:

    if ((C)->ZeroMdl) {                                                 \
        NT_ASSERT( (C)->ZeroMdl->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA |  \
                                          MDL_SOURCE_IS_NONPAGED_POOL));\
        if (NT_SUCCESS((I)->IoStatus.Status)) {                         \
            RtlZeroMemory( (C)->ZeroMdl->MappedSystemVa,                \
                           (C)->ZeroMdl->ByteCount );                   \
        }                                                               \
        IoFreeMdl((C)->ZeroMdl);                                        \
        (C)->ZeroMdl = NULL;                                            \
    }

Definition at line 171 of file deviosup.c.

FatLowLevelReadWrite

#define FatLowLevelReadWrite	(		IRPCONTEXT,
			DO,
			IRP,
			VCB
	)

Value:

    ( \
    IoCallDriver((DO),(IRP))                          \
)

Definition at line 163 of file deviosup.c.

FatUpdateIOCountersPCW

#define FatUpdateIOCountersPCW	(		IsAWrite,
			Count
	)

Value:

    FsRtlUpdateDiskCounters( ((IsAWrite) ? 0       : (Count) ),         \
                             ((IsAWrite) ? (Count) : 0) )

Definition at line 184 of file deviosup.c.

Typedef Documentation

FAT_PAGING_FILE_CONTEXT

typedef struct FAT_PAGING_FILE_CONTEXT FAT_PAGING_FILE_CONTEXT

FAT_SYNC_CONTEXT

typedef struct _FAT_SYNC_CONTEXT FAT_SYNC_CONTEXT

PFAT_PAGING_FILE_CONTEXT

typedef struct FAT_PAGING_FILE_CONTEXT * PFAT_PAGING_FILE_CONTEXT

PFAT_SYNC_CONTEXT

typedef struct _FAT_SYNC_CONTEXT * PFAT_SYNC_CONTEXT

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 880 of file deviosup.c.

{
 
    //
    // Declare some local variables for enumeration through the
    // runs of the file, and an array to store parameters for
    // parallel I/Os
    //
 
    BOOLEAN Wait;
 
    LBO NextLbo;
    VBO NextVbo;
    ULONG NextByteCount;
    BOOLEAN NextIsAllocated;
 
    LBO LastLbo;
    ULONG LastByteCount;
    BOOLEAN LastIsAllocated;
 
    BOOLEAN EndOnMax;
 
    ULONG FirstIndex;
    ULONG CurrentIndex;
    ULONG LastIndex;
 
    ULONG NextRun;
    ULONG BufferOffset;
    ULONG OriginalByteCount;
 
 
 
    IO_RUN StackIoRuns[FAT_MAX_IO_RUNS_ON_STACK];
    PIO_RUN IoRuns;
 
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( StreamFlags );
 
    DebugTrace(+1, Dbg, "FatNonCachedIo\n", 0);
    DebugTrace( 0, Dbg, "Irp           = %p\n", Irp );
    DebugTrace( 0, Dbg, "MajorFunction = %08lx\n", IrpContext->MajorFunction );
    DebugTrace( 0, Dbg, "FcbOrDcb      = %p\n", FcbOrDcb );
    DebugTrace( 0, Dbg, "StartingVbo   = %08lx\n", StartingVbo );
    DebugTrace( 0, Dbg, "ByteCount     = %08lx\n", ByteCount );
 
    if (!FlagOn(Irp->Flags, IRP_PAGING_IO)) {
 
        PFILE_SYSTEM_STATISTICS Stats =
            &FcbOrDcb->Vcb->Statistics[KeGetCurrentProcessorNumber() % FatData.NumberProcessors];
 
        if (IrpContext->MajorFunction == IRP_MJ_READ) {
            Stats->Fat.NonCachedReads += 1;
            Stats->Fat.NonCachedReadBytes += ByteCount;
        } else {
            Stats->Fat.NonCachedWrites += 1;
            Stats->Fat.NonCachedWriteBytes += ByteCount;
        }
    }
 
    //
    //  Initialize some locals.
    //
 
    NextRun = 0;
    BufferOffset = 0;
    OriginalByteCount = ByteCount;
 
    Wait = BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
 
    //
    //  Disk IO accounting
    //
 
    if (FatDiskAccountingEnabled) {
 
        FatUpdateDiskStats( IrpContext,
                            Irp,
                            ByteCount );
    }
#endif
 
    //
    // For nonbuffered I/O, we need the buffer locked in all
    // cases.
    //
    // This call may raise.  If this call succeeds and a subsequent
    // condition is raised, the buffers are unlocked automatically
    // by the I/O system when the request is completed, via the
    // Irp->MdlAddress field.
    //
 
    FatLockUserBuffer( IrpContext,
                       Irp,
                       (IrpContext->MajorFunction == IRP_MJ_READ) ?
                       IoWriteAccess : IoReadAccess,
                       ByteCount );
 
 
 
    //
    //  No zeroing for trailing sectors if requested.
    //  Otherwise setup the required zeroing for read requests.
    //
 
 
    if (UserByteCount != ByteCount) {
 
 
        PMDL Mdl;
 
        NT_ASSERT( ByteCount > UserByteCount );
        _Analysis_assume_(ByteCount > UserByteCount);
 
        Mdl = IoAllocateMdl( (PUCHAR) Irp->UserBuffer + UserByteCount,
                             ByteCount - UserByteCount,
                             FALSE,
                             FALSE,
                             NULL );
 
        if (Mdl == NULL) {
 
            FatRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
        }
 
        IoBuildPartialMdl( Irp->MdlAddress,
                           Mdl,
                           (PUCHAR) Irp->UserBuffer + UserByteCount,
                           ByteCount - UserByteCount );
 
        IrpContext->FatIoContext->ZeroMdl = Mdl;
 
        //
        //  Map the MDL now so we can't fail at IO completion time.  Note
        //  that this will be only a single page.
        //
 
        if (MmGetSystemAddressForMdlSafe( Mdl, NormalPagePriority | MdlMappingNoExecute ) == NULL) {
 
            FatRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
        }
    }
 
 
    //
    //  Try to lookup the first run.  If there is just a single run,
    //  we may just be able to pass it on.
    //
 
    FatLookupFileAllocation( IrpContext,
                             FcbOrDcb,
                             StartingVbo,
                             &NextLbo,
                             &NextByteCount,
                             &NextIsAllocated,
                             &EndOnMax,
                             &FirstIndex );
 
    //
    //  We just added the allocation, thus there must be at least
    //  one entry in the mcb corresponding to our write, ie.
    //  NextIsAllocated must be true.  If not, the pre-existing file
    //  must have an allocation error.
    //
 
    if ( !NextIsAllocated ) {
 
        FatPopUpFileCorrupt( IrpContext, FcbOrDcb );
 
        FatRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
    }
 
    NT_ASSERT( NextByteCount != 0 );
 
    //
    //  If the request was not aligned correctly, read in the first
    //  part first.
    //
 
 
    //
    //  See if the write covers a single valid run, and if so pass
    //  it on.  We must bias this by the byte that is lost at the
    //  end of the maximal file.
    //
 
    if ( NextByteCount >= ByteCount - (EndOnMax ? 1 : 0)) {
 
        if (FlagOn(Irp->Flags, IRP_PAGING_IO)) {
            CollectDiskIoStats(FcbOrDcb->Vcb, IrpContext->MajorFunction,
                               FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_USER_IO), 1);
        } else {
 
            PFILE_SYSTEM_STATISTICS Stats =
                &FcbOrDcb->Vcb->Statistics[KeGetCurrentProcessorNumber() % FatData.NumberProcessors];
 
            if (IrpContext->MajorFunction == IRP_MJ_READ) {
                Stats->Fat.NonCachedDiskReads += 1;
            } else {
                Stats->Fat.NonCachedDiskWrites += 1;
            }
        }
 
        DebugTrace( 0, Dbg, "Passing 1 Irp on to Disk Driver\n", 0 );
 
        FatSingleAsync( IrpContext,
                        FcbOrDcb->Vcb,
                        NextLbo,
                        ByteCount,
                        Irp );
 
    } else {
 
        //
        //  If there we can't wait, and there are more runs than we can handle,
        //  we will have to post this request.
        //
 
        FatLookupFileAllocation( IrpContext,
                                 FcbOrDcb,
                                 StartingVbo + ByteCount - 1,
                                 &LastLbo,
                                 &LastByteCount,
                                 &LastIsAllocated,
                                 &EndOnMax,
                                 &LastIndex );
 
        //
        // Since we already added the allocation for the whole
        // write, assert that we find runs until ByteCount == 0
        // Otherwise this file is corrupt.
        //
 
        if ( !LastIsAllocated ) {
 
            FatPopUpFileCorrupt( IrpContext, FcbOrDcb );
 
            FatRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
        }
 
        if (LastIndex - FirstIndex + 1 > FAT_MAX_IO_RUNS_ON_STACK) {
 
            IoRuns = FsRtlAllocatePoolWithTag( PagedPool,
                                               (LastIndex - FirstIndex + 1) * sizeof(IO_RUN),
                                               TAG_IO_RUNS );
 
        } else {
 
            IoRuns = StackIoRuns;
        }
 
        NT_ASSERT( LastIndex != FirstIndex );
 
        CurrentIndex = FirstIndex;
 
        //
        // Loop while there are still byte writes to satisfy.
        //
 
        while (CurrentIndex <= LastIndex) {
 
 
            NT_ASSERT( NextByteCount != 0);
            NT_ASSERT( ByteCount != 0);
 
            //
            // If next run is larger than we need, "ya get what you need".
            //
 
            if (NextByteCount > ByteCount) {
                NextByteCount = ByteCount;
            }
 
            //
            // Now that we have properly bounded this piece of the
            // transfer, it is time to write it.
            //
            // We remember each piece of a parallel run by saving the
            // essential information in the IoRuns array.  The tranfers
            // are started up in parallel below.
            //
 
            IoRuns[NextRun].Vbo = StartingVbo;
            IoRuns[NextRun].Lbo = NextLbo;
            IoRuns[NextRun].Offset = BufferOffset;
            IoRuns[NextRun].ByteCount = NextByteCount;
            NextRun += 1;
 
            //
            // Now adjust everything for the next pass through the loop.
            //
 
            StartingVbo += NextByteCount;
            BufferOffset += NextByteCount;
            ByteCount -= NextByteCount;
 
            //
            // Try to lookup the next run (if we are not done).
            //
 
            CurrentIndex += 1;
 
            if ( CurrentIndex <= LastIndex ) {
 
                NT_ASSERT( ByteCount != 0 );
 
                FatGetNextMcbEntry( FcbOrDcb->Vcb, &FcbOrDcb->Mcb,
                                    CurrentIndex,
                                    &NextVbo,
                                    &NextLbo,
                                    &NextByteCount );
 
 
                NT_ASSERT(NextVbo == StartingVbo);
 
 
            }
 
        } // while ( CurrentIndex <= LastIndex )
 
        //
        //  Now set up the Irp->IoStatus.  It will be modified by the
        //  multi-completion routine in case of error or verify required.
        //
 
        Irp->IoStatus.Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = OriginalByteCount;
 
        if (FlagOn(Irp->Flags, IRP_PAGING_IO)) {
            CollectDiskIoStats(FcbOrDcb->Vcb, IrpContext->MajorFunction,
                               FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_USER_IO), NextRun);
        }
 
        //
        //  OK, now do the I/O.
        //
 
        _SEH2_TRY {
 
            DebugTrace( 0, Dbg, "Passing Multiple Irps on to Disk Driver\n", 0 );
 
            FatMultipleAsync( IrpContext,
                              FcbOrDcb->Vcb,
                              Irp,
                              NextRun,
                              IoRuns );
 
        } _SEH2_FINALLY {
 
            if (IoRuns != StackIoRuns) {
 
                ExFreePool( IoRuns );
            }
        } _SEH2_END;
    }
 
    if (!Wait) {
 
        DebugTrace(-1, Dbg, "FatNonCachedIo -> STATUS_PENDING\n", 0);
        return STATUS_PENDING;
    }
 
    FatWaitSync( IrpContext );
 
 
    DebugTrace(-1, Dbg, "FatNonCachedIo -> 0x%08lx\n", Irp->IoStatus.Status);
    return Irp->IoStatus.Status;
}

FatBufferUserBuffer()

PVOID FatBufferUserBuffer	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PIRP	Irp,
		IN ULONG	BufferLength
	)

Definition at line 3411 of file deviosup.c.

{
    PUCHAR UserBuffer;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    PAGED_CODE();
 
    //
    //  Handle the no buffer case.
    //
 
    if (BufferLength == 0) {
 
        return NULL;
    }
 
    //
    //  If there is no system buffer we must have been supplied an Mdl
    //  describing the users input buffer, which we will now snapshot.
    //
 
    if (Irp->AssociatedIrp.SystemBuffer == NULL) {
 
        UserBuffer = FatMapUserBuffer( IrpContext, Irp );
 
        Irp->AssociatedIrp.SystemBuffer = FsRtlAllocatePoolWithQuotaTag( NonPagedPoolNx,
                                                                         BufferLength,
                                                                         TAG_IO_USER_BUFFER );
 
        //
        // Set the flags so that the completion code knows to deallocate the
        // buffer.
        //
 
        Irp->Flags |= (IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER);
 
        _SEH2_TRY {
 
            RtlCopyMemory( Irp->AssociatedIrp.SystemBuffer,
                           UserBuffer,
                           BufferLength );
 
        } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
 
              NTSTATUS Status;
 
              Status = _SEH2_GetExceptionCode();
              FatRaiseStatus( IrpContext,
                              FsRtlIsNtstatusExpected(Status) ? Status : STATUS_INVALID_USER_BUFFER );
        } _SEH2_END;
    }
 
    return Irp->AssociatedIrp.SystemBuffer;
}

Referenced by FatCommonSetEa().

FatBuildZeroMdl()

PMDL FatBuildZeroMdl	(	__in PIRP_CONTEXT	IrpContext,
		__in ULONG	Length
	)

Definition at line 3734 of file deviosup.c.

{
    PMDL ZeroMdl;
    ULONG SavedByteCount;
    PPFN_NUMBER Page;
    ULONG i;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Spin down trying to get an MDL which can describe our operation.
    //
 
    while (TRUE) {
 
        ZeroMdl = IoAllocateMdl( FatData.ZeroPage, Length, FALSE, FALSE, NULL );
 
        //
        //  Throttle ourselves to what we've physically allocated.  Note that
        //  we could have started with an odd multiple of this number.  If we
        //  tried for exactly that size and failed, we're toast.
        //
 
        if (ZeroMdl || (Length <= PAGE_SIZE)) {
 
            break;
        }
 
        //
        //  Fallback by half and round down to a page multiple.
        //
 
        ASSERT( IrpContext->Vcb->Bpb.BytesPerSector <= PAGE_SIZE );
        Length = BlockAlignTruncate( Length / 2, PAGE_SIZE );
        if (Length < PAGE_SIZE) {
            Length = PAGE_SIZE;
        }
    }
 
    if (ZeroMdl == NULL) {
        return NULL;
    }
 
    //
    //  If we have throttled all the way down, stop and just build a
    //  simple MDL describing our previous allocation.
    //
 
    if (Length == PAGE_SIZE) {
 
        MmBuildMdlForNonPagedPool( ZeroMdl );
        return ZeroMdl;
    }
 
    //
    //  Now we will temporarily lock the allocated pages
    //  only, and then replicate the page frame numbers through
    //  the entire Mdl to keep writing the same pages of zeros.
    //
    //  It would be nice if Mm exported a way for us to not have
    //  to pull the Mdl apart and rebuild it ourselves, but this
    //  is so bizarre a purpose as to be tolerable.
    //
 
    SavedByteCount = ZeroMdl->ByteCount;
    ZeroMdl->ByteCount = PAGE_SIZE;
    MmBuildMdlForNonPagedPool( ZeroMdl );
 
    ZeroMdl->MdlFlags &= ~MDL_SOURCE_IS_NONPAGED_POOL;
    ZeroMdl->MdlFlags |= MDL_PAGES_LOCKED;
    ZeroMdl->MappedSystemVa = NULL;
    ZeroMdl->StartVa = NULL;
    ZeroMdl->ByteCount = SavedByteCount;
    Page = MmGetMdlPfnArray( ZeroMdl );
    for (i = 1; i < (ADDRESS_AND_SIZE_TO_SPAN_PAGES( 0, SavedByteCount )); i++) {
        *(Page + i) = *(Page);
    }
 
 
    return ZeroMdl;
}

FatLockUserBuffer()

VOID FatLockUserBuffer	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PIRP	Irp,
		IN LOCK_OPERATION	Operation,
		IN ULONG	BufferLength
	)

Definition at line 3276 of file deviosup.c.

{
    PMDL Mdl = NULL;
 
    PAGED_CODE();
 
    if (Irp->MdlAddress == NULL) {
 
        //
        // Allocate the Mdl, and Raise if we fail.
        //
 
        Mdl = IoAllocateMdl( Irp->UserBuffer, BufferLength, FALSE, FALSE, Irp );
 
        if (Mdl == NULL) {
 
            FatRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
        }
 
        //
        // Now probe the buffer described by the Irp.  If we get an exception,
        // deallocate the Mdl and return the appropriate "expected" status.
        //
 
        _SEH2_TRY {
 
            MmProbeAndLockPages( Mdl,
                                 Irp->RequestorMode,
                                 Operation );
 
        } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
 
            NTSTATUS Status;
 
            Status = _SEH2_GetExceptionCode();
 
            IoFreeMdl( Mdl );
            Irp->MdlAddress = NULL;
 
            FatRaiseStatus( IrpContext,
                            FsRtlIsNtstatusExpected(Status) ? Status : STATUS_INVALID_USER_BUFFER );
        } _SEH2_END;
    }
 
    UNREFERENCED_PARAMETER( IrpContext );
}

Referenced by _Requires_lock_held_(), and FatPrePostIrp().

FatMapUserBuffer()

PVOID FatMapUserBuffer	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PIRP	Irp
	)

Definition at line 3357 of file deviosup.c.

{
    UNREFERENCED_PARAMETER( IrpContext );
 
    PAGED_CODE();
 
    //
    // If there is no Mdl, then we must be in the Fsd, and we can simply
    // return the UserBuffer field from the Irp.
    //
 
    if (Irp->MdlAddress == NULL) {
 
        return Irp->UserBuffer;
 
    } else {
 
        PVOID Address = MmGetSystemAddressForMdlSafe( Irp->MdlAddress, NormalPagePriority | MdlMappingNoExecute );
 
        if (Address == NULL) {
 
            ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES );
        }
 
        return Address;
    }
}

Referenced by _Requires_lock_held_(), FatBufferUserBuffer(), and FatCommonQueryEa().

FatMultiAsyncCompletionRoutine()

NTSTATUS NTAPI FatMultiAsyncCompletionRoutine	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_reads_opt_(_Inexpressible_("varies")) PVOID	Contxt
	)

Definition at line 2507 of file deviosup.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PFAT_IO_CONTEXT Context = Contxt;
    PIRP MasterIrp = Context->MasterIrp;
    BOOLEAN PostRequest = FALSE;
 
    DebugTrace(+1, Dbg, "FatMultiAsyncCompletionRoutine, Context = %p\n", Context );
 
    //
    //  If we got an error (or verify required), remember it in the Irp
    //
 
    if (!NT_SUCCESS( Irp->IoStatus.Status )) {
 
#if DBG
        if (!( NT_SUCCESS( FatBreakOnInterestingIoCompletion ) || Irp->IoStatus.Status != FatBreakOnInterestingIoCompletion )) {
            DbgBreakPoint();
        }
#endif
 
#ifdef SYSCACHE_COMPILE
        DbgPrint( "FAT SYSCACHE: MultiAsync (IRP %08x for Master %08x) -> %08x\n", Irp, MasterIrp, Irp->IoStatus );
#endif
 
        MasterIrp->IoStatus = Irp->IoStatus;
 
    }
 
    NT_ASSERT( !(NT_SUCCESS( Irp->IoStatus.Status ) && Irp->IoStatus.Information == 0 ));
 
    if (InterlockedDecrement(&Context->IrpCount) == 0) {
 
        FatDoCompletionZero( MasterIrp, Context );
 
        if (NT_SUCCESS(MasterIrp->IoStatus.Status)) {
 
            MasterIrp->IoStatus.Information =
                Context->Wait.Async.RequestedByteCount;
 
            NT_ASSERT(MasterIrp->IoStatus.Information != 0);
 
            //
            //  Now if this wasn't PagingIo, set either the read or write bit.
            //
 
            if (!FlagOn(MasterIrp->Flags, IRP_PAGING_IO)) {
 
                SetFlag( Context->Wait.Async.FileObject->Flags,
                         IoGetCurrentIrpStackLocation(MasterIrp)->MajorFunction == IRP_MJ_READ ?
                         FO_FILE_FAST_IO_READ : FO_FILE_MODIFIED );
            }
 
        } else {
 
            //
            // Post STATUS_VERIFY_REQUIRED failures. Only post top level IRPs, because recursive I/Os
            // cannot process volume verification.
            //
 
            if (!FlagOn(Context->IrpContextFlags, IRP_CONTEXT_FLAG_RECURSIVE_CALL) &&
                (MasterIrp->IoStatus.Status == STATUS_VERIFY_REQUIRED)) {
                PostRequest = TRUE;
            }
 
        }
 
        //
        //  If this was a special async write, decrement the count.  Set the
        //  event if this was the final outstanding I/O for the file.  We will
        //  also want to queue an APC to deal with any error conditionions.
        //
        _Analysis_assume_(!(Context->Wait.Async.NonPagedFcb) &&
        (ExInterlockedAddUlong( &Context->Wait.Async.NonPagedFcb->OutstandingAsyncWrites,
                                0xffffffff,
                                &FatData.GeneralSpinLock ) != 1));
        if ((Context->Wait.Async.NonPagedFcb) &&
            (ExInterlockedAddUlong( &Context->Wait.Async.NonPagedFcb->OutstandingAsyncWrites,
                                    0xffffffff,
                                    &FatData.GeneralSpinLock ) == 1)) {
 
            KeSetEvent( Context->Wait.Async.NonPagedFcb->OutstandingAsyncEvent, 0, FALSE );
        }
 
        //
        //  Now release the resources.
        //
 
        if (Context->Wait.Async.Resource != NULL) {
 
            ExReleaseResourceForThreadLite( Context->Wait.Async.Resource,
                                            Context->Wait.Async.ResourceThreadId );
        }
 
        if (Context->Wait.Async.Resource2 != NULL) {
 
            ExReleaseResourceForThreadLite( Context->Wait.Async.Resource2,
                                            Context->Wait.Async.ResourceThreadId );
        }
 
        //
        //  Mark the master Irp pending
        //
 
        IoMarkIrpPending( MasterIrp );
 
        //
        //  and finally, free the context record.
        //
 
        ExFreePool( Context );
 
        if (PostRequest) {
 
            PIRP_CONTEXT IrpContext = NULL;
 
            _SEH2_TRY {
 
                IrpContext = FatCreateIrpContext(Irp, TRUE );
                ClearFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL);
                FatFsdPostRequest( IrpContext, Irp );
                Status = STATUS_MORE_PROCESSING_REQUIRED;
 
            } _SEH2_EXCEPT( FatExceptionFilter(NULL, _SEH2_GetExceptionInformation()) ) {
 
                //
                // If we failed to post the IRP, we just have to return the failure
                // to the user. :(
                //
 
                NOTHING;
            } _SEH2_END;
        }
    }
 
    DebugTrace(-1, Dbg, "FatMultiAsyncCompletionRoutine -> SUCCESS\n", 0 );
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    return Status;
}

FatMultipleAsync()

VOID FatMultipleAsync	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN PIRP	MasterIrp,
		IN ULONG	MultipleIrpCount,
		IN PIO_RUN	IoRuns
	)

Definition at line 1622 of file deviosup.c.

{
    PIRP Irp;
    PIO_STACK_LOCATION IrpSp;
    PMDL Mdl;
    BOOLEAN Wait;
    PFAT_IO_CONTEXT Context;
#ifndef __REACTOS__
    BOOLEAN IsAWrite = FALSE;
    ULONG Length = 0;
#endif
 
    ULONG UnwindRunCount = 0;
 
    BOOLEAN ExceptionExpected = TRUE;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatMultipleAsync\n", 0);
    DebugTrace( 0, Dbg, "MajorFunction    = %08lx\n", IrpContext->MajorFunction );
    DebugTrace( 0, Dbg, "Vcb              = %p\n", Vcb );
    DebugTrace( 0, Dbg, "MasterIrp        = %p\n", MasterIrp );
    DebugTrace( 0, Dbg, "MultipleIrpCount = %08lx\n", MultipleIrpCount );
    DebugTrace( 0, Dbg, "IoRuns           = %08lx\n", IoRuns );
 
    //
    //  If this I/O originating during FatVerifyVolume, bypass the
    //  verify logic.
    //
 
    if (Vcb->VerifyThread == KeGetCurrentThread()) {
 
        SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_OVERRIDE_VERIFY );
    }
 
    //
    //  Set up things according to whether this is truely async.
    //
 
    Wait = BooleanFlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );
 
    Context = IrpContext->FatIoContext;
 
    //
    //  Finish initializing Context, for use in Read/Write Multiple Asynch.
    //
 
    Context->MasterIrp = MasterIrp;
 
    IrpSp = IoGetCurrentIrpStackLocation( MasterIrp );
#ifndef __REACTOS__
    IsAWrite = (IrpSp->MajorFunction == IRP_MJ_WRITE);
    Length = IrpSp->Parameters.Read.Length;
#endif
 
    _SEH2_TRY {
 
        //
        //  Itterate through the runs, doing everything that can fail
        //
 
        for ( UnwindRunCount = 0;
              UnwindRunCount < MultipleIrpCount;
              UnwindRunCount++ ) {
 
            //
            //  Create an associated IRP, making sure there is one stack entry for
            //  us, as well.
            //
 
            IoRuns[UnwindRunCount].SavedIrp = 0;
 
            Irp = IoMakeAssociatedIrp( MasterIrp,
                                       (CCHAR)(Vcb->TargetDeviceObject->StackSize + 1) );
 
            if (Irp == NULL) {
 
                FatRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
            }
 
            IoRuns[UnwindRunCount].SavedIrp = Irp;
 
            //
            // Allocate and build a partial Mdl for the request.
            //
 
            Mdl = IoAllocateMdl( (PCHAR)MasterIrp->UserBuffer +
                                 IoRuns[UnwindRunCount].Offset,
                                 IoRuns[UnwindRunCount].ByteCount,
                                 FALSE,
                                 FALSE,
                                 Irp );
 
            if (Mdl == NULL) {
 
                FatRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
            }
 
            //
            //  Sanity Check
            //
 
            NT_ASSERT( Mdl == Irp->MdlAddress );
 
            IoBuildPartialMdl( MasterIrp->MdlAddress,
                               Mdl,
                               (PCHAR)MasterIrp->UserBuffer +
                               IoRuns[UnwindRunCount].Offset,
                               IoRuns[UnwindRunCount].ByteCount );
 
            //
            //  Get the first IRP stack location in the associated Irp
            //
 
            IoSetNextIrpStackLocation( Irp );
            IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
            //
            //  Setup the Stack location to describe our read.
            //
 
            IrpSp->MajorFunction = IrpContext->MajorFunction;
            IrpSp->Parameters.Read.Length = IoRuns[UnwindRunCount].ByteCount;
            IrpSp->Parameters.Read.ByteOffset.QuadPart = IoRuns[UnwindRunCount].Vbo;
 
            //
            // Set up the completion routine address in our stack frame.
            //
 
            IoSetCompletionRoutine( Irp,
                                    Wait ?
                                    &FatMultiSyncCompletionRoutine :
                                    &FatMultiAsyncCompletionRoutine,
                                    Context,
                                    TRUE,
                                    TRUE,
                                    TRUE );
 
            //
            //  Setup the next IRP stack location in the associated Irp for the disk
            //  driver beneath us.
            //
 
            IrpSp = IoGetNextIrpStackLocation( Irp );
 
            //
            //  Setup the Stack location to do a read from the disk driver.
            //
 
            IrpSp->MajorFunction = IrpContext->MajorFunction;
            IrpSp->Parameters.Read.Length = IoRuns[UnwindRunCount].ByteCount;
            IrpSp->Parameters.Read.ByteOffset.QuadPart = IoRuns[UnwindRunCount].Lbo;
 
            //
            //  If this Irp is the result of a WriteThough operation,
            //  tell the device to write it through.
            //
 
            if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH )) {
 
                SetFlag( IrpSp->Flags, SL_WRITE_THROUGH );
            }
 
            //
            //  If this I/O requires override verify, bypass the verify logic.
            //
 
            if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_OVERRIDE_VERIFY )) {
 
                SetFlag( IrpSp->Flags, SL_OVERRIDE_VERIFY_VOLUME );
            }
        }
 
        //
        //  Now we no longer expect an exception.  If the driver raises, we
        //  must bugcheck, because we do not know how to recover from that
        //  case.
        //
 
        ExceptionExpected = FALSE;
 
        //
        //  We only need to set the associated IRP count in the master irp to
        //  make it a master IRP.  But we set the count to one more than our
        //  caller requested, because we do not want the I/O system to complete
        //  the I/O.  We also set our own count.
        //
 
        Context->IrpCount = MultipleIrpCount;
        MasterIrp->AssociatedIrp.IrpCount = MultipleIrpCount;
 
        if (Wait) {
 
            MasterIrp->AssociatedIrp.IrpCount += 1;
        }
        else if (FlagOn( Context->Wait.Async.ResourceThreadId, 3 )) {
 
            //
            //  For async requests if we acquired locks, transition the lock owners to an
            //  object, since when we return this thread could go away before request
            //  completion, and the resource package may try to boost priority.
            //
 
            if (Context->Wait.Async.Resource != NULL) {
 
                ExSetResourceOwnerPointer( Context->Wait.Async.Resource,
                                           (PVOID)Context->Wait.Async.ResourceThreadId );
            }
 
            if (Context->Wait.Async.Resource2 != NULL) {
 
                ExSetResourceOwnerPointer( Context->Wait.Async.Resource2,
                                           (PVOID)Context->Wait.Async.ResourceThreadId );
            }
        }
 
        //
        //  Back up a copy of the IrpContext flags for later use in async completion.
        //
 
        Context->IrpContextFlags = IrpContext->Flags;
 
        //
        //  Now that all the dangerous work is done, issue the read requests
        //
 
        for (UnwindRunCount = 0;
             UnwindRunCount < MultipleIrpCount;
             UnwindRunCount++) {
 
            Irp = IoRuns[UnwindRunCount].SavedIrp;
 
            DebugDoit( FatIoCallDriverCount += 1);
 
            //
            //  If IoCallDriver returns an error, it has completed the Irp
            //  and the error will be caught by our completion routines
            //  and dealt with as a normal IO error.
            //
 
            (VOID)FatLowLevelReadWrite( IrpContext,
                                        Vcb->TargetDeviceObject,
                                        Irp,
                                        Vcb );
        }
 
        //
        //  We just issued an IO to the storage stack, update the counters indicating so.
        //
 
        if (FatDiskAccountingEnabled) {
 
            FatUpdateIOCountersPCW( IsAWrite, Length );
        }
 
    } _SEH2_FINALLY {
 
        ULONG i;
 
        DebugUnwind( FatMultipleAsync );
 
        //
        //  Only allocating the spinlock, making the associated Irps
        //  and allocating the Mdls can fail.
        //
 
        if ( _SEH2_AbnormalTermination() ) {
 
            //
            //  If the driver raised, we are hosed.  He is not supposed to raise,
            //  and it is impossible for us to figure out how to clean up.
            //
 
            if (!ExceptionExpected) {
                NT_ASSERT( ExceptionExpected );
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
                FatBugCheck( 0, 0, 0 );
            }
 
            //
            //  Unwind
            //
 
            for (i = 0; i <= UnwindRunCount; i++) {
 
                if ( (Irp = IoRuns[i].SavedIrp) != NULL ) {
 
                    if ( Irp->MdlAddress != NULL ) {
 
                        IoFreeMdl( Irp->MdlAddress );
                    }
 
                    IoFreeIrp( Irp );
                }
            }
        }
 
        //
        //  And return to our caller
        //
 
        DebugTrace(-1, Dbg, "FatMultipleAsync -> VOID\n", 0);
    } _SEH2_END;
 
    return;
}

Referenced by _Requires_lock_held_(), and FatMultipleAsync().

FatMultiSyncCompletionRoutine()

NTSTATUS NTAPI FatMultiSyncCompletionRoutine	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_reads_opt_(_Inexpressible_("varies")) PVOID	Contxt
	)

Definition at line 2406 of file deviosup.c.

{
 
    PFAT_IO_CONTEXT Context = Contxt;
    PIRP MasterIrp = Context->MasterIrp;
 
    DebugTrace(+1, Dbg, "FatMultiSyncCompletionRoutine, Context = %p\n", Context );
 
    //
    //  If we got an error (or verify required), remember it in the Irp
    //
 
    if (!NT_SUCCESS( Irp->IoStatus.Status )) {
 
#if DBG
        if(!( NT_SUCCESS( FatBreakOnInterestingIoCompletion ) || Irp->IoStatus.Status != FatBreakOnInterestingIoCompletion )) {
            DbgBreakPoint();
        }
#endif
 
#ifdef SYSCACHE_COMPILE
        DbgPrint( "FAT SYSCACHE: MultiSync (IRP %08x for Master %08x) -> %08x\n", Irp, MasterIrp, Irp->IoStatus );
#endif
 
        MasterIrp->IoStatus = Irp->IoStatus;
    }
 
    NT_ASSERT( !(NT_SUCCESS( Irp->IoStatus.Status ) && Irp->IoStatus.Information == 0 ));
 
    //
    //  We must do this here since IoCompleteRequest won't get a chance
    //  on this associated Irp.
    //
 
    IoFreeMdl( Irp->MdlAddress );
    IoFreeIrp( Irp );
 
    if (InterlockedDecrement(&Context->IrpCount) == 0) {
 
        FatDoCompletionZero( MasterIrp, Context );
        KeSetEvent( &Context->Wait.SyncEvent, 0, FALSE );
    }
 
    DebugTrace(-1, Dbg, "FatMultiSyncCompletionRoutine -> SUCCESS\n", 0 );
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    return STATUS_MORE_PROCESSING_REQUIRED;
}

FatPagingFileCompletionRoutine()

NTSTATUS NTAPI FatPagingFileCompletionRoutine	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_reads_opt_(_Inexpressible_("varies")) PVOID	MasterIrp
	)

Definition at line 2898 of file deviosup.c.

{
    DebugTrace(+1, Dbg, "FatPagingFileCompletionRoutine, MasterIrp = %p\n", MasterIrp );
 
    //
    //  If we got an error (or verify required), remember it in the Irp
    //
 
    NT_ASSERT( !NT_SUCCESS( Irp->IoStatus.Status ));
 
    //
    //  If we were invoked with an assoicated Irp, copy the error over.
    //
 
    if (Irp != MasterIrp) {
 
        ((PIRP)MasterIrp)->IoStatus = Irp->IoStatus;
    }
 
    DebugTrace(-1, Dbg, "FatPagingFileCompletionRoutine => (done)\n", 0 );
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    return FatPagingFileErrorHandler( Irp, NULL );
}

FatPagingFileCompletionRoutineCatch()

NTSTATUS NTAPI FatPagingFileCompletionRoutineCatch	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_reads_opt_(_Inexpressible_("varies")) PVOID	Contxt
	)

Definition at line 2805 of file deviosup.c.

{
    PFAT_PAGING_FILE_CONTEXT Context = (PFAT_PAGING_FILE_CONTEXT) Contxt;
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    DebugTrace(+1, Dbg, "FatPagingFileCompletionRoutineCatch, Context = %p\n", Context );
 
    //
    //  Cleanup the existing Mdl, perhaps by returning the reserve.
    //
 
    if (Irp->MdlAddress == FatReserveMdl) {
 
        MmPrepareMdlForReuse( Irp->MdlAddress );
        KeSetEvent( &FatReserveEvent, 0, FALSE );
 
    } else {
 
        IoFreeMdl( Irp->MdlAddress );
    }
 
    //
    //  Restore the original Mdl.
    //
 
    Irp->MdlAddress = Context->RestoreMdl;
 
    DebugTrace(-1, Dbg, "FatPagingFileCompletionRoutine => (done)\n", 0 );
 
    //
    //  If the IRP is succeeding or the failure handler did not post off the
    //  completion, we're done and should set the event to let the master
    //  know the IRP is his again.
    //
 
    if (NT_SUCCESS( Irp->IoStatus.Status ) ||
        FatPagingFileErrorHandler( Irp, &Context->Event ) == STATUS_SUCCESS) {
 
        KeSetEvent( &Context->Event, 0, FALSE );
    }
 
    return STATUS_MORE_PROCESSING_REQUIRED;
 
}

FatPagingFileErrorHandler()

NTSTATUS FatPagingFileErrorHandler	(	IN PIRP	Irp,
		IN PKEVENT Event	OPTIONAL
	)

Definition at line 2695 of file deviosup.c.

{
    NTSTATUS Status;
 
    //
    //  If this was a media error, we want to chkdsk /r the next time we boot.
    //
 
    if (FsRtlIsTotalDeviceFailure(Irp->IoStatus.Status)) {
 
        Status = STATUS_SUCCESS;
 
    } else {
 
        PCLEAN_AND_DIRTY_VOLUME_PACKET Packet;
 
        //
        //  We are going to try to mark the volume needing recover.
        //  If we can't get pool, oh well....
        //
 
        Packet = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(CLEAN_AND_DIRTY_VOLUME_PACKET), ' taF');
 
        if ( Packet ) {
 
            Packet->Vcb = &((PVOLUME_DEVICE_OBJECT)IoGetCurrentIrpStackLocation(Irp)->DeviceObject)->Vcb;
            Packet->Irp = Irp;
            Packet->Event = Event;
 
            ExInitializeWorkItem( &Packet->Item,
                                  &FatFspMarkVolumeDirtyWithRecover,
                                  Packet );
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "prefast indicates this is obsolete, but it is ok for fastfat to use it" )
#endif
            ExQueueWorkItem( &Packet->Item, CriticalWorkQueue );
 
            Status = STATUS_MORE_PROCESSING_REQUIRED;
 
        } else {
 
            Status = STATUS_SUCCESS;
        }
    }
 
    return Status;
}

Referenced by FatPagingFileCompletionRoutine(), and FatPagingFileCompletionRoutineCatch().

FatPagingFileIo()

VOID FatPagingFileIo	(	IN PIRP	Irp,
		IN PFCB	Fcb
	)

Definition at line 211 of file deviosup.c.

{
    //
    // Declare some local variables for enumeration through the
    // runs of the file.
    //
 
    VBO Vbo;
    ULONG ByteCount;
 
    PMDL Mdl;
    LBO NextLbo;
    VBO NextVbo = 0;
    ULONG NextByteCount;
    ULONG RemainingByteCount;
    BOOLEAN MustSucceed;
 
    ULONG FirstIndex;
    ULONG CurrentIndex;
    ULONG LastIndex;
 
    LBO LastLbo;
    ULONG LastByteCount;
 
    BOOLEAN MdlIsReserve = FALSE;
    BOOLEAN IrpIsMaster = FALSE;
    FAT_PAGING_FILE_CONTEXT Context;
    LONG IrpCount;
 
    PIRP AssocIrp;
    PIO_STACK_LOCATION IrpSp;
    PIO_STACK_LOCATION NextIrpSp;
    ULONG BufferOffset;
    PDEVICE_OBJECT DeviceObject;
 
#ifndef __REACTOS__
    BOOLEAN IsAWrite = FALSE;
#endif
 
    DebugTrace(+1, Dbg, "FatPagingFileIo\n", 0);
    DebugTrace( 0, Dbg, "Irp = %p\n", Irp );
    DebugTrace( 0, Dbg, "Fcb = %p\n", Fcb );
 
    NT_ASSERT( FlagOn( Fcb->FcbState, FCB_STATE_PAGING_FILE ));
 
    //
    //  Initialize some locals.
    //
 
    BufferOffset = 0;
    DeviceObject = Fcb->Vcb->TargetDeviceObject;
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    Vbo = IrpSp->Parameters.Read.ByteOffset.LowPart;
    ByteCount = IrpSp->Parameters.Read.Length;
#ifndef __REACTOS__
    IsAWrite = (IrpSp->MajorFunction == IRP_MJ_WRITE);
#endif
 
    MustSucceed = FatLookupMcbEntry( Fcb->Vcb, &Fcb->Mcb,
                                     Vbo,
                                     &NextLbo,
                                     &NextByteCount,
                                     &FirstIndex);
 
    //
    //  If this run isn't present, something is very wrong.
    //
 
    if (!MustSucceed) {
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
        FatBugCheck( Vbo, ByteCount, 0 );
    }
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
 
    //
    //  Charge the IO to paging file to current thread
    //
 
    if (FatDiskAccountingEnabled) {
 
        PETHREAD ThreadIssuingIo = PsGetCurrentThread();
        BOOLEAN IsWriteOperation = FALSE;
 
        if (IrpSp->MajorFunction == IRP_MJ_WRITE) {
            IsWriteOperation = TRUE;
        }
 
        PsUpdateDiskCounters( PsGetThreadProcess( ThreadIssuingIo ),
                              (IsWriteOperation ? 0 : ByteCount ),       // bytes to read
                              (IsWriteOperation ? ByteCount : 0),       // bytes to write
                              (IsWriteOperation ? 0 : 1),               // # of reads
                              (IsWriteOperation ? 1 : 0),               // # of writes
                              0 );
    }
#endif
 
    // See if the write covers a single valid run, and if so pass
    // it on.
    //
 
    if ( NextByteCount >= ByteCount ) {
 
        DebugTrace( 0, Dbg, "Passing Irp on to Disk Driver\n", 0 );
 
        //
        //  Setup the next IRP stack location for the disk driver beneath us.
        //
 
        NextIrpSp = IoGetNextIrpStackLocation( Irp );
 
        NextIrpSp->MajorFunction = IrpSp->MajorFunction;
        NextIrpSp->Parameters.Read.Length = ByteCount;
        NextIrpSp->Parameters.Read.ByteOffset.QuadPart = NextLbo;
 
        //
        //  Since this is Paging file IO, we'll just ignore the verify bit.
        //
 
        SetFlag( NextIrpSp->Flags, SL_OVERRIDE_VERIFY_VOLUME );
 
        //
        //  Set up the completion routine address in our stack frame.
        //  This is only invoked on error or cancel, and just copies
        //  the error Status into master irp's iosb.
        //
        //  If the error implies a media problem, it also enqueues a
        //  worker item to write out the dirty bit so that the next
        //  time we run we will do a autochk /r
        //
 
        IoSetCompletionRoutine( Irp,
                                &FatPagingFileCompletionRoutine,
                                Irp,
                                FALSE,
                                TRUE,
                                TRUE );
 
        //
        //  Issue the read/write request
        //
        //  If IoCallDriver returns an error, it has completed the Irp
        //  and the error will be dealt with as a normal IO error.
        //
 
        (VOID)IoCallDriver( DeviceObject, Irp );
 
        //
        //  We just issued an IO to the storage stack, update the counters indicating so.
        //
 
        if (FatDiskAccountingEnabled) {
 
            FatUpdateIOCountersPCW( IsAWrite, ByteCount );
        }
 
        DebugTrace(-1, Dbg, "FatPagingFileIo -> VOID\n", 0);
        return;
    }
 
    //
    //  Find out how may runs there are.
    //
 
    MustSucceed = FatLookupMcbEntry( Fcb->Vcb, &Fcb->Mcb,
                                     Vbo + ByteCount - 1,
                                     &LastLbo,
                                     &LastByteCount,
                                     &LastIndex);
 
    //
    //  If this run isn't present, something is very wrong.
    //
 
    if (!MustSucceed) {
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
        FatBugCheck( Vbo + ByteCount - 1, 1, 0 );
    }
 
    CurrentIndex = FirstIndex;
 
    //
    //  Now set up the Irp->IoStatus.  It will be modified by the
    //  multi-completion routine in case of error or verify required.
    //
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = ByteCount;
 
    //
    //  Loop while there are still byte writes to satisfy.  The way we'll work this
    //  is to hope for the best - one associated IRP per run, which will let us be
    //  completely async after launching all the IO.
    //
    //  IrpCount will indicate the remaining number of associated Irps to launch.
    //
    //  All we have to do is make sure IrpCount doesn't hit zero before we're building
    //  the very last Irp.  If it is positive when we're done, it means we have to
    //  wait for the rest of the associated Irps to come back before we complete the
    //  master by hand.
    //
    //  This will keep the master from completing early.
    //
 
    Irp->AssociatedIrp.IrpCount = IrpCount = LastIndex - FirstIndex + 1;
 
    while (CurrentIndex <= LastIndex) {
 
        //
        //  Reset this for unwinding purposes
        //
 
        AssocIrp = NULL;
 
        //
        //  If next run is larger than we need, "ya get what ya need".
        //
 
        if (NextByteCount > ByteCount) {
            NextByteCount = ByteCount;
        }
 
        RemainingByteCount = 0;
 
        //
        // Allocate and build a partial Mdl for the request.
        //
 
        Mdl = IoAllocateMdl( (PCHAR)Irp->UserBuffer + BufferOffset,
                             NextByteCount,
                             FALSE,
                             FALSE,
                             AssocIrp );
 
        if (Mdl == NULL) {
 
            //
            //  Pick up the reserve MDL
            //
 
            KeWaitForSingleObject( &FatReserveEvent, Executive, KernelMode, FALSE, NULL );
 
            Mdl = FatReserveMdl;
            MdlIsReserve = TRUE;
 
            //
            //  Trim to fit the size of the reserve MDL.
            //
 
            if (NextByteCount > FAT_RESERVE_MDL_SIZE * PAGE_SIZE) {
 
                RemainingByteCount = NextByteCount - FAT_RESERVE_MDL_SIZE * PAGE_SIZE;
                NextByteCount = FAT_RESERVE_MDL_SIZE * PAGE_SIZE;
            }
        }
 
        IoBuildPartialMdl( Irp->MdlAddress,
                           Mdl,
                           (PCHAR)Irp->UserBuffer + BufferOffset,
                           NextByteCount );
 
        //
        //  Now that we have properly bounded this piece of the transfer, it is
        //  time to read/write it.  We can simplify life slightly by always
        //  re-using the master IRP for cases where we use the reserve MDL,
        //  since we'll always be synchronous for those and can use a single
        //  completion context on our local stack.
        //
        //  We also must prevent ourselves from issuing an associated IRP that would
        //  complete the master UNLESS this is the very last IRP we'll issue.
        //
        //  This logic looks a bit complicated, but is hopefully understandable.
        //
 
        if (!MdlIsReserve &&
            (IrpCount != 1 ||
             (CurrentIndex == LastIndex &&
              RemainingByteCount == 0))) {
 
            AssocIrp = IoMakeAssociatedIrp( Irp, (CCHAR)(DeviceObject->StackSize + 1) );
        }
 
        if (AssocIrp == NULL) {
 
            AssocIrp = Irp;
            IrpIsMaster = TRUE;
 
            //
            //  We need to drain the associated Irps so we can reliably figure out if
            //  the master Irp is showing a failed status, in which case we bail out
            //  immediately - as opposed to putting the value in the status field in
            //  jeopardy due to our re-use of the master Irp.
            //
 
            while (Irp->AssociatedIrp.IrpCount != IrpCount) {
 
                KeDelayExecutionThread (KernelMode, FALSE, &Fat30Milliseconds);
            }
 
            //
            //  Note that since we failed to launch this associated Irp, that the completion
            //  code at the bottom will take care of completing the master Irp.
            //
 
            if (!NT_SUCCESS(Irp->IoStatus.Status)) {
 
                NT_ASSERT( IrpCount );
                break;
            }
 
        } else {
 
            //
            //  Indicate we used an associated Irp.
            //
 
            IrpCount -= 1;
        }
 
        //
        //  With an associated IRP, we must take over the first stack location so
        //  we can have one to put the completion routine on.  When re-using the
        //  master IRP, its already there.
        //
 
        if (!IrpIsMaster) {
 
            //
            //  Get the first IRP stack location in the associated Irp
            //
 
            IoSetNextIrpStackLocation( AssocIrp );
            NextIrpSp = IoGetCurrentIrpStackLocation( AssocIrp );
 
            //
            //  Setup the Stack location to describe our read.
            //
 
            NextIrpSp->MajorFunction = IrpSp->MajorFunction;
            NextIrpSp->Parameters.Read.Length = NextByteCount;
            NextIrpSp->Parameters.Read.ByteOffset.QuadPart = Vbo;
 
            //
            //  We also need the VolumeDeviceObject in the Irp stack in case
            //  we take the failure path.
            //
 
            NextIrpSp->DeviceObject = IrpSp->DeviceObject;
 
        } else {
 
            //
            //  Save the MDL in the IRP and prepare the stack
            //  context for the completion routine.
            //
 
            KeInitializeEvent( &Context.Event, SynchronizationEvent, FALSE );
            Context.RestoreMdl = Irp->MdlAddress;
        }
 
        //
        //  And drop our Mdl into the Irp.
        //
 
        AssocIrp->MdlAddress = Mdl;
 
        //
        //  Set up the completion routine address in our stack frame.
        //  For true associated IRPs, this is only invoked on error or
        //  cancel, and just copies the error Status into master irp's
        //  iosb.
        //
        //  If the error implies a media problem, it also enqueues a
        //  worker item to write out the dirty bit so that the next
        //  time we run we will do a autochk /r
        //
 
        if (IrpIsMaster) {
 
            IoSetCompletionRoutine( AssocIrp,
                                    FatPagingFileCompletionRoutineCatch,
                                    &Context,
                                    TRUE,
                                    TRUE,
                                    TRUE );
 
        } else {
 
            IoSetCompletionRoutine( AssocIrp,
                                    FatPagingFileCompletionRoutine,
                                    Irp,
                                    FALSE,
                                    TRUE,
                                    TRUE );
        }
 
        //
        //  Setup the next IRP stack location for the disk driver beneath us.
        //
 
        NextIrpSp = IoGetNextIrpStackLocation( AssocIrp );
 
        //
        //  Since this is paging file IO, we'll just ignore the verify bit.
        //
 
        SetFlag( NextIrpSp->Flags, SL_OVERRIDE_VERIFY_VOLUME );
 
        //
        //  Setup the Stack location to do a read from the disk driver.
        //
 
        NextIrpSp->MajorFunction = IrpSp->MajorFunction;
        NextIrpSp->Parameters.Read.Length = NextByteCount;
        NextIrpSp->Parameters.Read.ByteOffset.QuadPart = NextLbo;
 
        (VOID)IoCallDriver( DeviceObject, AssocIrp );
 
        //
        //  We just issued an IO to the storage stack, update the counters indicating so.
        //
 
        if (FatDiskAccountingEnabled) {
 
            FatUpdateIOCountersPCW( IsAWrite, (ULONG64)NextByteCount );
        }
 
        //
        //  Wait for the Irp in the catch case and drop the flags.
        //
 
        if (IrpIsMaster) {
 
            KeWaitForSingleObject( &Context.Event, Executive, KernelMode, FALSE, NULL );
            IrpIsMaster = MdlIsReserve = FALSE;
 
            //
            //  If the Irp is showing a failed status, there is no point in continuing.
            //  In doing so, we get to avoid squirreling away the failed status in case
            //  we were to re-use the master irp again.
            //
            //  Note that since we re-used the master, we must not have issued the "last"
            //  associated Irp, and thus the completion code at the bottom will take care
            //  of that for us.
            //
 
            if (!NT_SUCCESS(Irp->IoStatus.Status)) {
 
                NT_ASSERT( IrpCount );
                break;
            }
        }
 
        //
        //  Now adjust everything for the next pass through the loop.
        //
 
        Vbo += NextByteCount;
        BufferOffset += NextByteCount;
        ByteCount -= NextByteCount;
 
        //
        //  Try to lookup the next run, if we are not done and we got
        //  all the way through the current run.
        //
 
        if (RemainingByteCount) {
 
            //
            //  Advance the Lbo/Vbo if we have more to do in the current run.
            //
 
            NextLbo += NextByteCount;
            NextVbo += NextByteCount;
 
            NextByteCount = RemainingByteCount;
 
        } else {
 
            CurrentIndex += 1;
 
            if ( CurrentIndex <= LastIndex ) {
 
                NT_ASSERT( ByteCount != 0 );
 
                FatGetNextMcbEntry( Fcb->Vcb, &Fcb->Mcb,
                                    CurrentIndex,
                                    &NextVbo,
                                    &NextLbo,
                                    &NextByteCount );
 
                NT_ASSERT( NextVbo == Vbo );
            }
        }
    } // while ( CurrentIndex <= LastIndex )
 
    //
    //  If we didn't get enough associated Irps going to make this asynchronous, we
    //  twiddle our thumbs and wait for those we did launch to complete.
    //
 
    if (IrpCount) {
 
        while (Irp->AssociatedIrp.IrpCount != IrpCount) {
 
            KeDelayExecutionThread (KernelMode, FALSE, &Fat30Milliseconds);
        }
 
        IoCompleteRequest( Irp, IO_DISK_INCREMENT );
    }
 
    DebugTrace(-1, Dbg, "FatPagingFileIo -> VOID\n", 0);
    return;
}

Referenced by _Function_class_(), and FatOverflowPagingFileRead().

FatPerformDevIoCtrl()

NTSTATUS FatPerformDevIoCtrl	(	IN PIRP_CONTEXT	IrpContext,
		IN ULONG	IoControlCode,
		IN PDEVICE_OBJECT	Device,
		IN PVOID InputBuffer	OPTIONAL,
		IN ULONG	InputBufferLength,
		OUT PVOID OutputBuffer	OPTIONAL,
		IN ULONG	OutputBufferLength,
		IN BOOLEAN	InternalDeviceIoControl,
		IN BOOLEAN	OverrideVerify,
		OUT PIO_STATUS_BLOCK Iosb	OPTIONAL
	)

Definition at line 3621 of file deviosup.c.

{
    NTSTATUS Status;
    PIRP Irp;
    KEVENT Event;
    IO_STATUS_BLOCK LocalIosb;
    PIO_STATUS_BLOCK IosbToUse = &LocalIosb;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Check if the user gave us an Iosb.
    //
 
    if (ARGUMENT_PRESENT( Iosb )) {
 
        IosbToUse = Iosb;
    }
 
    IosbToUse->Status = 0;
    IosbToUse->Information = 0;
 
    KeInitializeEvent( &Event, NotificationEvent, FALSE );
 
    Irp = IoBuildDeviceIoControlRequest( IoControlCode,
                                         Device,
                                         InputBuffer,
                                         InputBufferLength,
                                         OutputBuffer,
                                         OutputBufferLength,
                                         InternalDeviceIoControl,
                                         &Event,
                                         IosbToUse );
 
    if (Irp == NULL) {
 
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    if (OverrideVerify) {
 
        SetFlag( IoGetNextIrpStackLocation( Irp )->Flags, SL_OVERRIDE_VERIFY_VOLUME );
    }
 
    Status = IoCallDriver( Device, Irp );
 
    //
    //  We check for device not ready by first checking Status
    //  and then if status pending was returned, the Iosb status
    //  value.
    //
 
    if (Status == STATUS_PENDING) {
 
        (VOID) KeWaitForSingleObject( &Event,
                                      Executive,
                                      KernelMode,
                                      FALSE,
                                      (PLARGE_INTEGER)NULL );
 
        Status = IosbToUse->Status;
    }
 
    return Status;
}

Referenced by _Requires_lock_held_(), and FatScanForDataTrack().

FatSingleAsync()

VOID FatSingleAsync	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN LBO	Lbo,
		IN ULONG	ByteCount,
		IN PIRP	Irp
	)

Definition at line 1990 of file deviosup.c.

{
    PIO_STACK_LOCATION IrpSp;
    PFAT_IO_CONTEXT Context;
#ifndef __REACTOS__
    BOOLEAN IsAWrite = FALSE;
#endif
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatSingleAsync\n", 0);
    DebugTrace( 0, Dbg, "MajorFunction = %08lx\n", IrpContext->MajorFunction );
    DebugTrace( 0, Dbg, "Vcb           = %p\n", Vcb );
    DebugTrace( 0, Dbg, "Lbo           = %08lx\n", Lbo);
    DebugTrace( 0, Dbg, "ByteCount     = %08lx\n", ByteCount);
    DebugTrace( 0, Dbg, "Irp           = %p\n", Irp );
 
    //
    //  If this I/O originating during FatVerifyVolume, bypass the
    //  verify logic.
    //
 
    if (Vcb->VerifyThread == KeGetCurrentThread()) {
 
        SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_OVERRIDE_VERIFY );
    }
 
    //
    //  Set up the completion routine address in our stack frame.
    //
 
    IoSetCompletionRoutine( Irp,
                            FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) ?
                            &FatSingleSyncCompletionRoutine :
                            &FatSingleAsyncCompletionRoutine,
                            IrpContext->FatIoContext,
                            TRUE,
                            TRUE,
                            TRUE );
 
    //
    //  Setup the next IRP stack location in the associated Irp for the disk
    //  driver beneath us.
    //
 
    IrpSp = IoGetNextIrpStackLocation( Irp );
 
    //
    //  Setup the Stack location to do a read from the disk driver.
    //
 
    IrpSp->MajorFunction = IrpContext->MajorFunction;
    IrpSp->Parameters.Read.Length = ByteCount;
    IrpSp->Parameters.Read.ByteOffset.QuadPart = Lbo;
 
#ifndef __REACTOS__
    IsAWrite = (IrpSp->MajorFunction == IRP_MJ_WRITE);
#endif
 
    //
    //  If this Irp is the result of a WriteThough operation,
    //  tell the device to write it through.
    //
 
    if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH )) {
 
        SetFlag( IrpSp->Flags, SL_WRITE_THROUGH );
    }
 
    //
    //  If this I/O requires override verify, bypass the verify logic.
    //
 
    if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_OVERRIDE_VERIFY )) {
 
        SetFlag( IrpSp->Flags, SL_OVERRIDE_VERIFY_VOLUME );
    }
 
    //
    //  For async requests if we acquired locks, transition the lock owners to an
    //  object, since when we return this thread could go away before request
    //  completion, and the resource package may try to boost priority.
    //
 
    if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT ) &&
        FlagOn( IrpContext->FatIoContext->Wait.Async.ResourceThreadId, 3 )) {
 
        Context = IrpContext->FatIoContext;
 
        if (Context->Wait.Async.Resource != NULL) {
 
            ExSetResourceOwnerPointer( Context->Wait.Async.Resource,
                                       (PVOID)Context->Wait.Async.ResourceThreadId );
        }
 
        if (Context->Wait.Async.Resource2 != NULL) {
 
            ExSetResourceOwnerPointer( Context->Wait.Async.Resource2,
                                       (PVOID)Context->Wait.Async.ResourceThreadId );
        }
    }
 
    //
    //  Back up a copy of the IrpContext flags for later use in async completion.
    //
 
    IrpContext->FatIoContext->IrpContextFlags = IrpContext->Flags;
 
    //
    //  Issue the read request
    //
 
    DebugDoit( FatIoCallDriverCount += 1);
 
    //
    //  If IoCallDriver returns an error, it has completed the Irp
    //  and the error will be caught by our completion routines
    //  and dealt with as a normal IO error.
    //
 
    (VOID)FatLowLevelReadWrite( IrpContext,
                                Vcb->TargetDeviceObject,
                                Irp,
                                Vcb );
 
    //
    //  We just issued an IO to the storage stack, update the counters indicating so.
    //
 
    if (FatDiskAccountingEnabled) {
 
        FatUpdateIOCountersPCW( IsAWrite, ByteCount );
    }
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatSingleAsync -> VOID\n", 0);
 
    return;
}

Referenced by _Requires_lock_held_().

FatSingleAsyncCompletionRoutine()

NTSTATUS NTAPI FatSingleAsyncCompletionRoutine	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_reads_opt_(_Inexpressible_("varies")) PVOID	Contxt
	)

Definition at line 3106 of file deviosup.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    PFAT_IO_CONTEXT Context = Contxt;
    BOOLEAN PostRequest = FALSE;
 
    DebugTrace(+1, Dbg, "FatSingleAsyncCompletionRoutine, Context = %p\n", Context );
 
    //
    //  Fill in the information field correctedly if this worked.
    //
 
    FatDoCompletionZero( Irp, Context );
 
    if (NT_SUCCESS(Irp->IoStatus.Status)) {
 
        NT_ASSERT( Irp->IoStatus.Information != 0 );
        Irp->IoStatus.Information = Context->Wait.Async.RequestedByteCount;
        NT_ASSERT( Irp->IoStatus.Information != 0 );
 
        //
        //  Now if this wasn't PagingIo, set either the read or write bit.
        //
 
        if (!FlagOn(Irp->Flags, IRP_PAGING_IO)) {
 
            SetFlag( Context->Wait.Async.FileObject->Flags,
                     IoGetCurrentIrpStackLocation(Irp)->MajorFunction == IRP_MJ_READ ?
                     FO_FILE_FAST_IO_READ : FO_FILE_MODIFIED );
        }
 
    } else {
 
#if DBG
        if(!( NT_SUCCESS( FatBreakOnInterestingIoCompletion ) || Irp->IoStatus.Status != FatBreakOnInterestingIoCompletion )) {
            DbgBreakPoint();
        }
#endif
 
#ifdef SYSCACHE_COMPILE
        DbgPrint( "FAT SYSCACHE: SingleAsync (IRP %08x) -> %08x\n", Irp, Irp->IoStatus );
#endif
 
        //
        // Post STATUS_VERIFY_REQUIRED failures. Only post top level IRPs, because recursive I/Os
        // cannot process volume verification.
        //
 
        if (!FlagOn(Context->IrpContextFlags, IRP_CONTEXT_FLAG_RECURSIVE_CALL) &&
            (Irp->IoStatus.Status == STATUS_VERIFY_REQUIRED)) {
            PostRequest = TRUE;
        }
 
    }
 
    //
    //  If this was a special async write, decrement the count.  Set the
    //  event if this was the final outstanding I/O for the file.  We will
    //  also want to queue an APC to deal with any error conditionions.
    //
    _Analysis_assume_(!(Context->Wait.Async.NonPagedFcb) &&
        (ExInterlockedAddUlong( &Context->Wait.Async.NonPagedFcb->OutstandingAsyncWrites,
                                0xffffffff,
                                &FatData.GeneralSpinLock ) != 1));
 
    if ((Context->Wait.Async.NonPagedFcb) &&
        (ExInterlockedAddUlong( &Context->Wait.Async.NonPagedFcb->OutstandingAsyncWrites,
                                0xffffffff,
                                &FatData.GeneralSpinLock ) == 1)) {
 
        KeSetEvent( Context->Wait.Async.NonPagedFcb->OutstandingAsyncEvent, 0, FALSE );
    }
 
    //
    //  Now release the resources
    //
 
    if (Context->Wait.Async.Resource != NULL) {
 
        ExReleaseResourceForThreadLite( Context->Wait.Async.Resource,
                                    Context->Wait.Async.ResourceThreadId );
    }
 
    if (Context->Wait.Async.Resource2 != NULL) {
 
        ExReleaseResourceForThreadLite( Context->Wait.Async.Resource2,
                                    Context->Wait.Async.ResourceThreadId );
    }
 
    //
    //  Mark the Irp pending
    //
 
    IoMarkIrpPending( Irp );
 
    //
    //  and finally, free the context record.
    //
 
    ExFreePool( Context );
 
    if (PostRequest) {
 
        PIRP_CONTEXT IrpContext = NULL;
 
        _SEH2_TRY {
 
            IrpContext = FatCreateIrpContext(Irp, TRUE );
            ClearFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL);
            FatFsdPostRequest( IrpContext, Irp );
            Status = STATUS_MORE_PROCESSING_REQUIRED;
 
        } _SEH2_EXCEPT( FatExceptionFilter(NULL, _SEH2_GetExceptionInformation()) ) {
 
            //
            // If we failed to post the IRP, we just have to return the failure
            // to the user. :(
            //
 
            NOTHING;
        } _SEH2_END;
    }
 
 
    DebugTrace(-1, Dbg, "FatSingleAsyncCompletionRoutine -> STATUS_MORE_PROCESSING_REQUIRED\n", 0 );
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    return Status;
}

FatSingleNonAlignedSync()

VOID FatSingleNonAlignedSync	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN PUCHAR	Buffer,
		IN LBO	Lbo,
		IN ULONG	ByteCount,
		IN PIRP	Irp
	)

Definition at line 2171 of file deviosup.c.

{
    PIO_STACK_LOCATION IrpSp;
 
    PMDL Mdl;
    PMDL SavedMdl;
#ifndef __REACTOS__
    BOOLEAN IsAWrite = FALSE;
#endif
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatSingleNonAlignedAsync\n", 0);
    DebugTrace( 0, Dbg, "MajorFunction = %08lx\n", IrpContext->MajorFunction );
    DebugTrace( 0, Dbg, "Vcb           = %p\n", Vcb );
    DebugTrace( 0, Dbg, "Buffer        = %p\n", Buffer );
    DebugTrace( 0, Dbg, "Lbo           = %08lx\n", Lbo);
    DebugTrace( 0, Dbg, "ByteCount     = %08lx\n", ByteCount);
    DebugTrace( 0, Dbg, "Irp           = %p\n", Irp );
 
    //
    //  Create a new Mdl describing the buffer, saving the current one in the
    //  Irp
    //
 
    SavedMdl = Irp->MdlAddress;
 
    Irp->MdlAddress = 0;
 
    Mdl = IoAllocateMdl( Buffer,
                         ByteCount,
                         FALSE,
                         FALSE,
                         Irp );
 
    if (Mdl == NULL) {
 
        Irp->MdlAddress = SavedMdl;
 
        FatRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
    }
 
    //
    //  Lock the new Mdl in memory.
    //
 
    _SEH2_TRY {
 
        MmProbeAndLockPages( Mdl, KernelMode, IoWriteAccess );
 
    } _SEH2_FINALLY {
 
        if ( _SEH2_AbnormalTermination() ) {
 
            IoFreeMdl( Mdl );
            Irp->MdlAddress = SavedMdl;
        }
    } _SEH2_END;
 
    //
    // Set up the completion routine address in our stack frame.
    //
 
    IoSetCompletionRoutine( Irp,
                            &FatSingleSyncCompletionRoutine,
                            IrpContext->FatIoContext,
                            TRUE,
                            TRUE,
                            TRUE );
 
    //
    //  Setup the next IRP stack location in the associated Irp for the disk
    //  driver beneath us.
    //
 
    IrpSp = IoGetNextIrpStackLocation( Irp );
 
    //
    //  Setup the Stack location to do a read from the disk driver.
    //
 
    IrpSp->MajorFunction = IrpContext->MajorFunction;
    IrpSp->Parameters.Read.Length = ByteCount;
    IrpSp->Parameters.Read.ByteOffset.QuadPart = Lbo;
 
#ifndef __REACTOS__
    IsAWrite = (IrpSp->MajorFunction == IRP_MJ_WRITE);
#endif
 
    //
    //  If this I/O originating during FatVerifyVolume, bypass the
    //  verify logic.
    //
 
    if (Vcb->VerifyThread == KeGetCurrentThread()) {
 
        SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_OVERRIDE_VERIFY );
    }
 
    //
    //  If this I/O requires override verify, bypass the verify logic.
    //
 
    if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_OVERRIDE_VERIFY )) {
 
        SetFlag( IrpSp->Flags, SL_OVERRIDE_VERIFY_VOLUME );
    }
 
    //
    //  Issue the read request
    //
 
    DebugDoit( FatIoCallDriverCount += 1);
 
    //
    //  If IoCallDriver returns an error, it has completed the Irp
    //  and the error will be caught by our completion routines
    //  and dealt with as a normal IO error.
    //
 
    _SEH2_TRY {
 
        (VOID)FatLowLevelReadWrite( IrpContext,
                                    Vcb->TargetDeviceObject,
                                    Irp,
                                    Vcb );
 
        FatWaitSync( IrpContext );
 
    } _SEH2_FINALLY {
 
        MmUnlockPages( Mdl );
        IoFreeMdl( Mdl );
        Irp->MdlAddress = SavedMdl;
    } _SEH2_END;
 
    //
    //  We just issued an IO to the storage stack, update the counters indicating so.
    //
 
    if (FatDiskAccountingEnabled) {
 
        FatUpdateIOCountersPCW( IsAWrite, ByteCount );
    }
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatSingleNonAlignedSync -> VOID\n", 0);
 
    return;
}

FatSingleSyncCompletionRoutine()

NTSTATUS NTAPI FatSingleSyncCompletionRoutine	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_reads_opt_(_Inexpressible_("varies")) PVOID	Contxt
	)

Definition at line 3034 of file deviosup.c.

{
    PFAT_IO_CONTEXT Context = Contxt;
 
    DebugTrace(+1, Dbg, "FatSingleSyncCompletionRoutine, Context = %p\n", Context );
 
    FatDoCompletionZero( Irp, Context );
 
    if (!NT_SUCCESS( Irp->IoStatus.Status )) {
 
#if DBG
        if(!( NT_SUCCESS( FatBreakOnInterestingIoCompletion ) || Irp->IoStatus.Status != FatBreakOnInterestingIoCompletion )) {
            DbgBreakPoint();
        }
#endif
 
    }
 
    NT_ASSERT( !(NT_SUCCESS( Irp->IoStatus.Status ) && Irp->IoStatus.Information == 0 ));
 
    KeSetEvent( &Context->Wait.SyncEvent, 0, FALSE );
 
    DebugTrace(-1, Dbg, "FatSingleSyncCompletionRoutine -> STATUS_MORE_PROCESSING_REQUIRED\n", 0 );
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    return STATUS_MORE_PROCESSING_REQUIRED;
}

FatSpecialSyncCompletionRoutine()

NTSTATUS NTAPI FatSpecialSyncCompletionRoutine	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_reads_opt_(_Inexpressible_("varies")) PVOID	Contxt
	)

Definition at line 2967 of file deviosup.c.

{
    PFAT_SYNC_CONTEXT SyncContext = (PFAT_SYNC_CONTEXT)Contxt;
 
    UNREFERENCED_PARAMETER( Irp );
 
    DebugTrace(+1, Dbg, "FatSpecialSyncCompletionRoutine, Context = %p\n", Contxt );
 
    SyncContext->Iosb = Irp->IoStatus;
 
    KeSetEvent( &SyncContext->Event, 0, FALSE );
 
    DebugTrace(-1, Dbg, "FatSpecialSyncCompletionRoutine -> STATUS_SUCCESS\n", 0 );
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    return STATUS_SUCCESS;
}

FatToggleMediaEjectDisable()

NTSTATUS FatToggleMediaEjectDisable	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN BOOLEAN	PreventRemoval
	)

Definition at line 3495 of file deviosup.c.

{
    PIRP Irp;
    KIRQL SavedIrql;
    NTSTATUS Status;
    FAT_SYNC_CONTEXT SyncContext;
    PREVENT_MEDIA_REMOVAL Prevent;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  If PreventRemoval is the same as VCB_STATE_FLAG_REMOVAL_PREVENTED,
    //  no-op this call, otherwise toggle the state of the flag.
    //
 
    KeAcquireSpinLock( &FatData.GeneralSpinLock, &SavedIrql );
 
    if ((PreventRemoval ^
         BooleanFlagOn(Vcb->VcbState, VCB_STATE_FLAG_REMOVAL_PREVENTED)) == 0) {
 
        KeReleaseSpinLock( &FatData.GeneralSpinLock, SavedIrql );
 
        return STATUS_SUCCESS;
 
    } else {
 
        Vcb->VcbState ^= VCB_STATE_FLAG_REMOVAL_PREVENTED;
 
        KeReleaseSpinLock( &FatData.GeneralSpinLock, SavedIrql );
    }
 
    Prevent.PreventMediaRemoval = PreventRemoval;
 
    KeInitializeEvent( &SyncContext.Event, NotificationEvent, FALSE );
 
    //
    //  We build this IRP using a junk Iosb that will receive the final
    //  completion status since we won't be around for it.
    //
    // We fill in the UserIosb manually below,
    // So passing NULL for the final parameter is ok in this special case.
    //
#ifdef _MSC_VER
#pragma warning(suppress: 6387)
#endif
    Irp = IoBuildDeviceIoControlRequest( IOCTL_DISK_MEDIA_REMOVAL,
                                         Vcb->TargetDeviceObject,
                                         &Prevent,
                                         sizeof(PREVENT_MEDIA_REMOVAL),
                                         NULL,
                                         0,
                                         FALSE,
                                         NULL,
                                         NULL );
 
    if ( Irp != NULL ) {
 
        //
        //  Use our special completion routine which will remove the requirement that
        //  the caller must be below APC level.  All it tells us is that the Irp got
        //  back, but will not tell us if it was succesful or not.  We don't care,
        //  and there is of course no fallback if the attempt to prevent removal
        //  doesn't work for some mysterious reason.
        //
        //  Normally, all IO is done at passive level. However, MM needs to be able
        //  to issue IO with fast mutexes locked down, which raises us to APC.  The
        //  overlying IRP is set up to complete in yet another magical fashion even
        //  though APCs are disabled, and any IRPage we do in these cases has to do
        //  the same.  Marking media dirty (and toggling eject state) is one.
        //
 
        Irp->UserIosb = &Irp->IoStatus;
 
        IoSetCompletionRoutine( Irp,
                                FatSpecialSyncCompletionRoutine,
                                &SyncContext,
                                TRUE,
                                TRUE,
                                TRUE );
 
        Status = IoCallDriver( Vcb->TargetDeviceObject, Irp );
 
        if (Status == STATUS_PENDING) {
 
            (VOID) KeWaitForSingleObject( &SyncContext.Event,
                                          Executive,
                                          KernelMode,
                                          FALSE,
                                          NULL );
 
            Status = SyncContext.Iosb.Status;
        }
 
        return Status;
    }
 
    return STATUS_INSUFFICIENT_RESOURCES;
}

Referenced by _Requires_lock_held_(), and FatDeferredCleanVolume().

FatUpdateDiskStats()

VOID FatUpdateDiskStats	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp,
		IN ULONG	ByteCount
	)

Definition at line 760 of file deviosup.c.

{
    PETHREAD OriginatingThread = NULL;
    ULONG NumReads = 0;
    ULONG NumWrites = 0;
    ULONGLONG BytesToRead = 0;
    ULONGLONG BytesToWrite = 0;
 
    //
    //  Here we attempt to charge the IO back to the originating process.
    //   - These checks are intended to cover following cases:
    //      o Buffered sync reads
    //      o Unbuffered sync read
    //      o Inline metadata reads
    //      o memory mapped reads (in-line faulting of data)
    //
 
    if (IrpContext->MajorFunction == IRP_MJ_READ) {
 
        NumReads++;
        BytesToRead = ByteCount;
 
        if ((Irp->Tail.Overlay.Thread != NULL) &&
            !IoIsSystemThread( Irp->Tail.Overlay.Thread )) {
 
            OriginatingThread = Irp->Tail.Overlay.Thread;
 
        } else if (!IoIsSystemThread( PsGetCurrentThread() )) {
 
            OriginatingThread = PsGetCurrentThread();
 
        //
        //  We couldn't find a non-system entity, so this should be charged to system.
        //  Do so only if we are top level.
        //  If we are not top-level then the read was initiated by someone like Cc (read ahead)
        //  who should have already accounted for this IO.
        //
 
        } else if (IoIsSystemThread( PsGetCurrentThread() ) &&
                   (IoGetTopLevelIrp() == Irp)) {
 
            OriginatingThread = PsGetCurrentThread();
        }
 
    //
    //  Charge the write to Originating process.
    //  Intended to cover the following writes:
    //      - Unbuffered sync write
    //      - unbuffered async write
    //
    //  If we re not top-level, then it should already have been accounted for
    //  somewhere else (Cc).
    //
 
    } else if (IrpContext->MajorFunction == IRP_MJ_WRITE) {
 
        NumWrites++;
        BytesToWrite = ByteCount;
 
        if (IoGetTopLevelIrp() == Irp) {
 
            if ((Irp->Tail.Overlay.Thread != NULL) &&
                !IoIsSystemThread( Irp->Tail.Overlay.Thread )) {
 
                OriginatingThread = Irp->Tail.Overlay.Thread;
 
            } else {
 
                OriginatingThread = PsGetCurrentThread();
            }
 
        //
        //  For mapped page writes
        //
 
        } else if (IoGetTopLevelIrp() == (PIRP)FSRTL_MOD_WRITE_TOP_LEVEL_IRP) {
 
            OriginatingThread = PsGetCurrentThread();
        }
    }
 
    if (OriginatingThread != NULL) {
 
        PsUpdateDiskCounters( PsGetThreadProcess( OriginatingThread ),
                              BytesToRead,
                              BytesToWrite,
                              NumReads,
                              NumWrites,
                              0 );
    }
}

Referenced by _Requires_lock_held_().

FatWaitSync()

VOID FatWaitSync

(

IN PIRP_CONTEXT

IrpContext

)

Definition at line 2367 of file deviosup.c.

{
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatWaitSync, Context = %p\n", IrpContext->FatIoContext );
 
    KeWaitForSingleObject( &IrpContext->FatIoContext->Wait.SyncEvent,
                           Executive, KernelMode, FALSE, NULL );
 
    KeClearEvent( &IrpContext->FatIoContext->Wait.SyncEvent );
 
    DebugTrace(-1, Dbg, "FatWaitSync -> VOID\n", 0 );
}

Referenced by _Requires_lock_held_(), and FatSingleNonAlignedSync().

Variable Documentation

FatMultiAsyncCompletionRoutine

NTSTATUS NTAPI FatMultiAsyncCompletionRoutine

Definition at line 78 of file deviosup.c.

Referenced by FatMultipleAsync().

FatMultiSyncCompletionRoutine

NTSTATUS NTAPI FatMultiSyncCompletionRoutine

Definition at line 68 of file deviosup.c.

Referenced by FatMultipleAsync().

FatPagingFileCompletionRoutine

NTSTATUS NTAPI FatPagingFileCompletionRoutine

Definition at line 118 of file deviosup.c.

Referenced by FatPagingFileIo().

FatPagingFileCompletionRoutineCatch

NTSTATUS NTAPI FatPagingFileCompletionRoutineCatch

Definition at line 128 of file deviosup.c.

Referenced by FatPagingFileIo().

FatSingleAsyncCompletionRoutine

NTSTATUS NTAPI FatSingleAsyncCompletionRoutine

Definition at line 108 of file deviosup.c.

Referenced by FatSingleAsync().

FatSingleSyncCompletionRoutine

NTSTATUS NTAPI FatSingleSyncCompletionRoutine

Definition at line 98 of file deviosup.c.

Referenced by FatSingleAsync(), and FatSingleNonAlignedSync().

FatSpecialSyncCompletionRoutine

NTSTATUS NTAPI FatSpecialSyncCompletionRoutine

Definition at line 88 of file deviosup.c.

Referenced by FatToggleMediaEjectDisable().