fastio.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for fastio.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
VOID NTAPI	FsRtlIncrementCcFastReadResourceMiss (VOID)
VOID NTAPI	FsRtlIncrementCcFastReadNotPossible (VOID)
VOID NTAPI	FsRtlIncrementCcFastReadWait (VOID)
VOID NTAPI	FsRtlIncrementCcFastReadNoWait (VOID)
BOOLEAN NTAPI	FsRtlCopyRead (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
BOOLEAN NTAPI	FsRtlCopyWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	FsRtlGetFileSize (IN PFILE_OBJECT FileObject, IN OUT PLARGE_INTEGER FileSize)
BOOLEAN NTAPI	FsRtlMdlRead (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG LockKey, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
BOOLEAN NTAPI	FsRtlMdlReadComplete (IN PFILE_OBJECT FileObject, IN OUT PMDL MdlChain)
BOOLEAN NTAPI	FsRtlMdlReadCompleteDev (IN PFILE_OBJECT FileObject, IN PMDL MemoryDescriptorList, IN PDEVICE_OBJECT DeviceObject)
BOOLEAN NTAPI	FsRtlMdlReadDev (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG LockKey, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
BOOLEAN NTAPI	FsRtlMdlWriteComplete (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PMDL MdlChain)
BOOLEAN NTAPI	FsRtlMdlWriteCompleteDev (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PMDL MdlChain, IN PDEVICE_OBJECT DeviceObject)
BOOLEAN NTAPI	FsRtlPrepareMdlWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG LockKey, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
BOOLEAN NTAPI	FsRtlPrepareMdlWriteDev (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG LockKey, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	FsRtlAcquireFileExclusiveCommon (IN PFILE_OBJECT FileObject, IN FS_FILTER_SECTION_SYNC_TYPE SyncType, IN ULONG Reserved)
VOID NTAPI	FsRtlAcquireFileExclusive (IN PFILE_OBJECT FileObject)
NTSTATUS NTAPI	FsRtlAcquireToCreateMappedSection (_In_ PFILE_OBJECT FileObject, _In_ ULONG SectionPageProtection)
VOID NTAPI	FsRtlReleaseFile (IN PFILE_OBJECT FileObject)
NTSTATUS NTAPI	FsRtlAcquireFileForCcFlushEx (IN PFILE_OBJECT FileObject)
VOID NTAPI	FsRtlAcquireFileForCcFlush (IN PFILE_OBJECT FileObject)
VOID NTAPI	FsRtlReleaseFileForCcFlush (IN PFILE_OBJECT FileObject)
static BOOLEAN	FsRtlpGetResourceForModWrite (_In_ PFSRTL_COMMON_FCB_HEADER FcbHeader, _In_ PLARGE_INTEGER EndingOffset, _Outptr_result_maybenull_ PERESOURCE *ResourceToAcquire)
	Get the resource to acquire when Mod Writer flushes data to disk.
_Check_return_ NTSTATUS NTAPI	FsRtlAcquireFileForModWriteEx (_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER EndingOffset, _Outptr_result_maybenull_ PERESOURCE *ResourceToRelease)
	Lock a file object before flushing pages to disk. To be called by the Modified Page Writer (MPW)
VOID NTAPI	FsRtlReleaseFileForModWrite (_In_ PFILE_OBJECT FileObject, _In_ PERESOURCE ResourceToRelease)
	Unlock a file object after flushing pages to disk. To be called by the Modified Page Writer (MPW) after a succesful call to FsRtlAcquireFileForModWriteEx.
NTSTATUS NTAPI	FsRtlRegisterFileSystemFilterCallbacks (PDRIVER_OBJECT FilterDriverObject, PFS_FILTER_CALLBACKS Callbacks)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file fastio.c.

Function Documentation

FsRtlAcquireFileExclusive()

VOID NTAPI FsRtlAcquireFileExclusive

(

IN PFILE_OBJECT

FileObject

)

Definition at line 1640 of file fastio.c.

{
    PAGED_CODE();
 
    /* Call the common routine. Don't care about the result */
    (VOID)FsRtlAcquireFileExclusiveCommon(FileObject, SyncTypeOther, 0);
}

Referenced by MiRosUnmapViewOfSection(), and MmNotPresentFaultSectionView().

FsRtlAcquireFileExclusiveCommon()

NTSTATUS NTAPI FsRtlAcquireFileExclusiveCommon	(	IN PFILE_OBJECT	FileObject,
		IN FS_FILTER_SECTION_SYNC_TYPE	SyncType,
		IN ULONG	Reserved
	)

Definition at line 1557 of file fastio.c.

{
    PFSRTL_COMMON_FCB_HEADER FcbHeader;
    PDEVICE_OBJECT DeviceObject;
    PFAST_IO_DISPATCH FastDispatch;
    PEXTENDED_DRIVER_EXTENSION DriverExtension;
    PFS_FILTER_CALLBACKS FilterCallbacks;
 
    /* Get Device Object and Fast Calls */
    FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
 
    /* Get master FsRtl lock */
    FsRtlEnterFileSystem();
 
    DriverExtension = (PEXTENDED_DRIVER_EXTENSION)DeviceObject->DriverObject->DriverExtension;
    FilterCallbacks = DriverExtension->FsFilterCallbacks;
 
    /* Check if Filter Cllbacks are supported */
    if (FilterCallbacks && FilterCallbacks->PreAcquireForSectionSynchronization)
    {
        NTSTATUS Status;
        PVOID CompletionContext;
 
        FS_FILTER_CALLBACK_DATA CbData;
 
        RtlZeroMemory(&CbData, sizeof(CbData));
 
        CbData.SizeOfFsFilterCallbackData = sizeof(CbData);
        CbData.Operation = FS_FILTER_ACQUIRE_FOR_SECTION_SYNCHRONIZATION;
        CbData.DeviceObject = DeviceObject;
        CbData.FileObject = FileObject;
        CbData.Parameters.AcquireForSectionSynchronization.PageProtection = Reserved;
        CbData.Parameters.AcquireForSectionSynchronization.SyncType = SyncType;
 
        Status = FilterCallbacks->PreAcquireForSectionSynchronization(&CbData, &CompletionContext);
        if (!NT_SUCCESS(Status))
        {
            FsRtlExitFileSystem();
            return Status;
        }
 
        /* Should we do something in-between ? */
 
        if (FilterCallbacks->PostAcquireForSectionSynchronization)
        {
            FilterCallbacks->PostAcquireForSectionSynchronization(&CbData, Status, CompletionContext);
        }
 
        /* Return here when the status is based on the synchonization type and write access to the file */
        if (Status == STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY ||
            Status == STATUS_FILE_LOCKED_WITH_ONLY_READERS ||
            Status == STATUS_FILE_LOCKED_WITH_WRITERS)
        {
            return Status;
        }
    }
 
    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 
    /* Check if Fast Calls are supported, and check AcquireFileForNtCreateSection */
    if (FastDispatch &&
        FastDispatch->AcquireFileForNtCreateSection)
    {
        /* Call the AcquireFileForNtCreateSection FastIo handler */
        FastDispatch->AcquireFileForNtCreateSection(FileObject);
    }
    else
    {
        /* No FastIo handler, acquire file's resource exclusively */
        if (FcbHeader && FcbHeader->Resource) ExAcquireResourceExclusiveLite(FcbHeader->Resource, TRUE);
    }
 
    return STATUS_SUCCESS;
}

Referenced by FsRtlAcquireFileExclusive(), and FsRtlAcquireToCreateMappedSection().

FsRtlAcquireFileForCcFlush()

VOID NTAPI FsRtlAcquireFileForCcFlush

(

IN PFILE_OBJECT

FileObject

)

Definition at line 1757 of file fastio.c.

{
    PAGED_CODE();
 
    /* Call the common routine. Don't care about the result */
    (VOID)FsRtlAcquireFileForCcFlushEx(FileObject);
}

FsRtlAcquireFileForCcFlushEx()

NTSTATUS NTAPI FsRtlAcquireFileForCcFlushEx

(

IN PFILE_OBJECT

FileObject

)

Definition at line 1698 of file fastio.c.

{
    PFSRTL_COMMON_FCB_HEADER FcbHeader;
    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
    PFAST_IO_DISPATCH FastDispatch;
    NTSTATUS Status;
 
    /* Get the Base File System (Volume) and Fast Calls */
    FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 
    /* Get master FsRtl lock */
    FsRtlEnterFileSystem();
 
    /* Check if Fast Calls are supported, and check AcquireForCcFlush */
    if (FastDispatch &&
        FastDispatch->AcquireForCcFlush)
    {
        /* Call the AcquireForCcFlush FastIo handler */
        Status = FastDispatch->AcquireForCcFlush(FileObject, BaseDeviceObject);
 
        /* Return either success or inability to wait.
           In case of other failure - fall through */
        if (NT_SUCCESS(Status))
            return Status;
 
        if (Status == STATUS_CANT_WAIT)
        {
            DPRINT1("STATUS_CANT_WAIT\n");
            FsRtlExitFileSystem();
            return Status;
        }
    }
 
    /* No FastIo handler (or it failed). Acquire Main resource */
    if (FcbHeader->Resource)
    {
        /* Acquire it - either shared if it's already acquired
            or exclusively if we are the first */
        if (ExIsResourceAcquiredSharedLite(FcbHeader->Resource))
            ExAcquireResourceSharedLite(FcbHeader->Resource, TRUE);
        else
            ExAcquireResourceExclusiveLite(FcbHeader->Resource, TRUE);
    }
 
    /* Also acquire its PagingIO resource */
    if (FcbHeader->PagingIoResource)
        ExAcquireResourceSharedLite(FcbHeader->PagingIoResource, TRUE);
 
    return STATUS_SUCCESS;
}

Referenced by CcRosFlushVacb(), and FsRtlAcquireFileForCcFlush().

FsRtlAcquireFileForModWriteEx()

_Check_return_ NTSTATUS NTAPI FsRtlAcquireFileForModWriteEx	(	_In_ PFILE_OBJECT	FileObject,
		_In_ PLARGE_INTEGER	EndingOffset,
		_Outptr_result_maybenull_ PERESOURCE *	ResourceToRelease
	)

Lock a file object before flushing pages to disk. To be called by the Modified Page Writer (MPW)

Parameters

FileObject	- The file object to lock
EndingOffset	- The end offset of the write to be done
ResourceToRelease	- Pointer receiving the resource to release after the write

Returns

Relevant NTSTATUS value

Definition at line 1858 of file fastio.c.

{
    PFSRTL_COMMON_FCB_HEADER FcbHeader;
    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
    PFAST_IO_DISPATCH FastDispatch;
    PERESOURCE ResourceToAcquire = NULL;
    BOOLEAN Exclusive;
    BOOLEAN Result;
    NTSTATUS Status = STATUS_SUCCESS;
 
    /* Get Device Object and Fast Calls */
    FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 
    /* Check if Fast Calls are supported, and check AcquireForModWrite */
    if (FastDispatch &&
        FastDispatch->AcquireForModWrite)
    {
        /* Call the AcquireForModWrite FastIo handler */
        Status = FastDispatch->AcquireForModWrite(FileObject,
                                                  EndingOffset,
                                                  ResourceToRelease,
                                                  BaseDeviceObject);
 
        /* Return either success or inability to wait.
           In case of other failure - fall through */
        if (Status == STATUS_SUCCESS ||
            Status == STATUS_CANT_WAIT)
        {
            return Status;
        }
    }
 
    /* Check what and how we should acquire */
    Exclusive = FsRtlpGetResourceForModWrite(FcbHeader, EndingOffset, &ResourceToAcquire);
 
    /* Acquire the resource and loop until we're sure we got this right. */
    while (TRUE)
    {
        BOOLEAN OldExclusive;
        PERESOURCE OldResourceToAcquire;
 
        if (ResourceToAcquire == NULL)
        {
            /* 
             * There's nothing to acquire, we can simply return success
             */
 
            break;
        }
 
        if (Exclusive)
        {
            Result = ExAcquireResourceExclusiveLite(ResourceToAcquire, FALSE);
        }
        else
        {
            Result = ExAcquireSharedWaitForExclusive(ResourceToAcquire, FALSE);
        }
 
        if (!Result)
        {
            return STATUS_CANT_WAIT;
        }
 
        /* Does this still hold true? */
        OldExclusive = Exclusive;
        OldResourceToAcquire = ResourceToAcquire;
        Exclusive = FsRtlpGetResourceForModWrite(FcbHeader, EndingOffset, &ResourceToAcquire);
 
        if ((OldExclusive == Exclusive) && (OldResourceToAcquire == ResourceToAcquire))
        {
            /* We're good */
            break;
        }
 
        /* Can we fix this situation? */
        if ((OldResourceToAcquire == ResourceToAcquire) && !Exclusive)
        {
            /* We can easily do so */
            ExConvertExclusiveToSharedLite(ResourceToAcquire);
            break;
        }
 
        /* Things have changed since we acquired the lock. Start again */
        ExReleaseResourceLite(OldResourceToAcquire);
    }
 
    /* If we're here, this means that we succeeded */
    *ResourceToRelease = ResourceToAcquire;
    return STATUS_SUCCESS;
}

FsRtlAcquireToCreateMappedSection()

NTSTATUS NTAPI FsRtlAcquireToCreateMappedSection	(	_In_ PFILE_OBJECT	FileObject,
		_In_ ULONG	SectionPageProtection
	)

Definition at line 1653 of file fastio.c.

{
    PAGED_CODE();
 
    return FsRtlAcquireFileExclusiveCommon(FileObject, SyncTypeCreateSection, SectionPageProtection);
}

Referenced by MmCreateArm3Section(), and MmCreateSection().

FsRtlCopyRead()

BOOLEAN NTAPI FsRtlCopyRead	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN ULONG	Length,
		IN BOOLEAN	Wait,
		IN ULONG	LockKey,
		OUT PVOID	Buffer,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 64 of file fastio.c.

{
 
    PFSRTL_COMMON_FCB_HEADER FcbHeader;
    LARGE_INTEGER Offset;
    PFAST_IO_DISPATCH FastIoDispatch;
    PDEVICE_OBJECT Device;
    BOOLEAN Result = TRUE;
    ULONG PageCount = ADDRESS_AND_SIZE_TO_SPAN_PAGES(FileOffset, Length);
 
    PAGED_CODE();
    ASSERT(FileObject);
    ASSERT(FileObject->FsContext);
 
    /* No actual read */
    if (!Length)
    {
        /* Return success */
        IoStatus->Status = STATUS_SUCCESS;
        IoStatus->Information = 0;
        return TRUE;
    }
 
    if (Length > MAXLONGLONG - FileOffset->QuadPart)
    {
        IoStatus->Status = STATUS_INVALID_PARAMETER;
        IoStatus->Information = 0;
        return FALSE;
    }
 
    /* Get the offset and FCB header */
    Offset.QuadPart = FileOffset->QuadPart + Length;
    FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
 
    if (Wait)
    {
        /* Use a Resource Acquire */
        FsRtlEnterFileSystem();
        CcFastReadWait++;
        ExAcquireResourceSharedLite(FcbHeader->Resource, TRUE);
    }
    else
    {
        /* Acquire the resource without blocking. Return false and the I/O manager
         * will retry using the standard IRP method. Use a Resource Acquire.
         */
        FsRtlEnterFileSystem();
        if (!ExAcquireResourceSharedLite(FcbHeader->Resource, FALSE))
        {
            FsRtlExitFileSystem();
            FsRtlIncrementCcFastReadResourceMiss();
            return FALSE;
        }
    }
 
    /* Check if this is a fast I/O cached file */
    if (!(FileObject->PrivateCacheMap) ||
        (FcbHeader->IsFastIoPossible == FastIoIsNotPossible))
    {
        /* It's not, so fail */
        Result = FALSE;
        goto Cleanup;
    }
 
    /* Check if we need to find out if fast I/O is available */
    if (FcbHeader->IsFastIoPossible == FastIoIsQuestionable)
    {
        /* Sanity check */
        ASSERT(!KeIsExecutingDpc());
 
        /* Get the Fast I/O table */
        Device = IoGetRelatedDeviceObject(FileObject);
        FastIoDispatch = Device->DriverObject->FastIoDispatch;
 
        /* Sanity check */
        ASSERT(FastIoDispatch != NULL);
        ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL);
 
        /* Ask the driver if we can do it */
        if (!FastIoDispatch->FastIoCheckIfPossible(FileObject,
                                                   FileOffset,
                                                   Length,
                                                   TRUE,
                                                   LockKey,
                                                   TRUE,
                                                   IoStatus,
                                                   Device))
        {
            /* It's not, fail */
            Result = FALSE;
            goto Cleanup;
        }
    }
 
    /* Check if we read too much */
    if (Offset.QuadPart > FcbHeader->FileSize.QuadPart)
    {
        /* We did, check if the file offset is past the end */
        if (FileOffset->QuadPart >= FcbHeader->FileSize.QuadPart)
        {
            /* Set end of file */
            IoStatus->Status = STATUS_END_OF_FILE;
            IoStatus->Information = 0;
            goto Cleanup;
        }
 
        /* Otherwise, just normalize the length */
        Length = (ULONG)(FcbHeader->FileSize.QuadPart - FileOffset->QuadPart);
    }
 
    /* Set this as top-level IRP */
    PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP;
 
    _SEH2_TRY
    {
        /* Make sure the IO and file size is below 4GB */
        if (Wait && !(Offset.HighPart | FcbHeader->FileSize.HighPart))
        {
 
            /* Call the cache controller */
            CcFastCopyRead(FileObject,
                           FileOffset->LowPart,
                           Length,
                           PageCount,
                           Buffer,
                           IoStatus);
 
            /* File was accessed */
            FileObject->Flags |= FO_FILE_FAST_IO_READ;
 
            if (IoStatus->Status != STATUS_END_OF_FILE)
            {
                ASSERT((ULONGLONG)FcbHeader->FileSize.QuadPart >=
                      ((ULONGLONG)FileOffset->QuadPart + IoStatus->Information));
            }
        }
        else
        {
 
            /* Call the cache controller */
            Result = CcCopyRead(FileObject,
                                FileOffset,
                                Length,
                                Wait,
                                Buffer,
                                IoStatus);
 
            /* File was accessed */
            FileObject->Flags |= FO_FILE_FAST_IO_READ;
 
            if (Result != FALSE)
            {
                ASSERT((IoStatus->Status == STATUS_END_OF_FILE) ||
                       (((ULONGLONG)FileOffset->QuadPart + IoStatus->Information) <=
                        (ULONGLONG)FcbHeader->FileSize.QuadPart));
            }
        }
 
        /* Update the current file offset */
        if (Result != FALSE)
        {
            FileObject->CurrentByteOffset.QuadPart = FileOffset->QuadPart + IoStatus->Information;
        }
    }
    _SEH2_EXCEPT(FsRtlIsNtstatusExpected(_SEH2_GetExceptionCode()) ?
                 EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
    {
        Result = FALSE;
    }
    _SEH2_END;
 
    PsGetCurrentThread()->TopLevelIrp = 0;
 
    /* Return to caller */
Cleanup:
 
    ExReleaseResourceLite(FcbHeader->Resource);
    FsRtlExitFileSystem();
 
    if (Result == FALSE)
    {
        CcFastReadNotPossible += 1;
    }
 
    return Result;
}

Referenced by CdInitializeGlobalData(), Ext2FastIoRead(), FsRtlTest_StartTest(), init_fast_io_dispatch(), and UDFInitializeFunctionPointers().

FsRtlCopyWrite()

BOOLEAN NTAPI FsRtlCopyWrite	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN ULONG	Length,
		IN BOOLEAN	Wait,
		IN ULONG	LockKey,
		OUT PVOID	Buffer,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 264 of file fastio.c.

{
    BOOLEAN Result = TRUE;
    PFAST_IO_DISPATCH FastIoDispatch;
    PDEVICE_OBJECT Device;
    PFSRTL_COMMON_FCB_HEADER FcbHeader;
    PSHARED_CACHE_MAP SharedCacheMap;
 
    /* WDK doc.
     * Offset == 0xffffffffffffffff indicates append to the end of file.
     */
    BOOLEAN FileOffsetAppend = (FileOffset->HighPart == (LONG)0xffffffff) &&
                               (FileOffset->LowPart == 0xffffffff);
 
    BOOLEAN ResourceAcquiredShared = FALSE;
    BOOLEAN b_4GB = FALSE;
    BOOLEAN FileSizeModified = FALSE;
    LARGE_INTEGER OldFileSize;
    LARGE_INTEGER OldValidDataLength;
    LARGE_INTEGER NewSize;
    LARGE_INTEGER Offset;
 
    PAGED_CODE();
 
    ASSERT(FileObject);
    ASSERT(FileObject->FsContext);
 
    /* Initialize some of the vars and pointers */
    NewSize.QuadPart = 0;
    Offset.QuadPart = FileOffset->QuadPart + Length;
    FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
 
    /* Nagar p.544.
     * Check with Cc if we can write and check if the IO > 64kB (WDK macro).
     */
    if ((CcCanIWrite(FileObject, Length, Wait, FALSE) == FALSE) ||
        (CcCopyWriteWontFlush(FileObject, FileOffset, Length) == FALSE) ||
        ((FileObject->Flags & FO_WRITE_THROUGH)))
    {
        return FALSE;
    }
 
    /* Already init IO_STATUS_BLOCK */
    IoStatus->Status = STATUS_SUCCESS;
    IoStatus->Information = Length;
 
    /* No actual read */
    if (!Length)
    {
        return TRUE;
    }
 
    FsRtlEnterFileSystem();
 
    /* Nagar p.544/545.
     * The CcFastCopyWrite doesn't deal with filesize beyond 4GB.
     */
    if (Wait && (FcbHeader->AllocationSize.HighPart == 0))
    {
        /* If the file offset is not past the file size,
         * then we can acquire the lock shared.
         */
        if ((FileOffsetAppend == FALSE) &&
            (Offset.LowPart <= FcbHeader->ValidDataLength.LowPart))
        {
            ExAcquireResourceSharedLite(FcbHeader->Resource, TRUE);
            ResourceAcquiredShared = TRUE;
        }
        else
        {
            ExAcquireResourceExclusiveLite(FcbHeader->Resource, TRUE);
        }
 
        /* Nagar p.544/545.
         * If we append, use the file size as offset.
         * Also, check that we aren't crossing the 4GB boundary.
         */
        if (FileOffsetAppend != FALSE)
        {
            Offset.LowPart = FcbHeader->FileSize.LowPart;
            NewSize.LowPart = FcbHeader->FileSize.LowPart + Length;
            b_4GB = (NewSize.LowPart < FcbHeader->FileSize.LowPart);
 
        }
        else
        {
            Offset.LowPart = FileOffset->LowPart;
            NewSize.LowPart = FileOffset->LowPart + Length;
            b_4GB = (NewSize.LowPart < FileOffset->LowPart) ||
                    (FileOffset->HighPart != 0);
        }
 
        /* Nagar p.544/545.
         * Make sure that caching is initated.
         * That fast are allowed for this file stream.
         * That we are not extending past the allocated size.
         * That we are not creating a hole bigger than 8k.
         * That we are not crossing the 4GB boundary.
         */
        if ((FileObject->PrivateCacheMap != NULL) &&
            (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
            (FcbHeader->AllocationSize.LowPart >= NewSize.LowPart) &&
            (Offset.LowPart < FcbHeader->ValidDataLength.LowPart + 0x2000) &&
            !b_4GB)
        {
            /* If we are extending past the file size, we need to
             * release the lock and acquire it exclusively, because
             * we are going to need to update the FcbHeader.
             */
            if (ResourceAcquiredShared &&
                (NewSize.LowPart > FcbHeader->ValidDataLength.LowPart + 0x2000))
            {
                /* Then we need to acquire the resource exclusive */
                ExReleaseResourceLite(FcbHeader->Resource);
                ExAcquireResourceExclusiveLite(FcbHeader->Resource, TRUE);
                if (FileOffsetAppend != FALSE)
                {
                    Offset.LowPart = FcbHeader->FileSize.LowPart; // ??
                    NewSize.LowPart = FcbHeader->FileSize.LowPart + Length;
 
                    /* Make sure we don't cross the 4GB boundary */
                    b_4GB = (NewSize.LowPart < Offset.LowPart);
                }
 
                /* Recheck some of the conditions since we let the lock go */
                if ((FileObject->PrivateCacheMap != NULL) &&
                    (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
                    (FcbHeader->AllocationSize.LowPart >= NewSize.LowPart) &&
                    (FcbHeader->AllocationSize.HighPart == 0) &&
                    !b_4GB)
                {
                    /* Do nothing? */
                }
                else
                {
                    goto FailAndCleanup;
                }
            }
 
        }
        else
        {
            goto FailAndCleanup;
        }
 
        /* Check if we need to find out if fast I/O is available */
        if (FcbHeader->IsFastIoPossible == FastIoIsQuestionable)
        {
            IO_STATUS_BLOCK FastIoCheckIfPossibleStatus;
 
            /* Sanity check */
            ASSERT(!KeIsExecutingDpc());
 
            /* Get the Fast I/O table */
            Device = IoGetRelatedDeviceObject(FileObject);
            FastIoDispatch = Device->DriverObject->FastIoDispatch;
 
            /* Sanity check */
            ASSERT(FastIoDispatch != NULL);
            ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL);
 
            /* Ask the driver if we can do it */
            if (!FastIoDispatch->FastIoCheckIfPossible(FileObject,
                                                       FileOffsetAppend ?
                                                        &FcbHeader->FileSize :
                                                        FileOffset,
                                                       Length,
                                                       TRUE,
                                                       LockKey,
                                                       FALSE,
                                                       &FastIoCheckIfPossibleStatus,
                                                       Device))
            {
                /* It's not, fail */
                goto FailAndCleanup;
            }
        }
 
        /* If we are going to extend the file then save
         * the old file size in case the operation fails.
         */
        if (NewSize.LowPart > FcbHeader->FileSize.LowPart)
        {
            FileSizeModified = TRUE;
            OldFileSize.LowPart = FcbHeader->FileSize.LowPart;
            OldValidDataLength.LowPart = FcbHeader->ValidDataLength.LowPart;
            FcbHeader->FileSize.LowPart = NewSize.LowPart;
        }
 
        /* Set this as top-level IRP */
        PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP;
 
        _SEH2_TRY
        {
            if (Offset.LowPart > FcbHeader->ValidDataLength.LowPart)
            {
                LARGE_INTEGER OffsetVar;
                OffsetVar.LowPart = Offset.LowPart;
                OffsetVar.HighPart = 0;
                CcZeroData(FileObject, &FcbHeader->ValidDataLength, &OffsetVar, TRUE);
            }
 
            /* Call the cache manager */
            CcFastCopyWrite(FileObject, Offset.LowPart, Length, Buffer);
        }
        _SEH2_EXCEPT(FsRtlIsNtstatusExpected(_SEH2_GetExceptionCode()) ?
                                             EXCEPTION_EXECUTE_HANDLER :
                                             EXCEPTION_CONTINUE_SEARCH)
        {
            Result = FALSE;
        }
        _SEH2_END;
 
        /* Remove ourselves at the top level component after the IO is done */
        PsGetCurrentThread()->TopLevelIrp = 0;
 
        /* Did the operation succeed? */
        if (Result != FALSE)
        {
            /* Update the valid file size if necessary */
            if (NewSize.LowPart > FcbHeader->ValidDataLength.LowPart)
            {
                FcbHeader->ValidDataLength.LowPart = NewSize.LowPart;
            }
 
            /* Flag the file as modified */
            FileObject->Flags |= FO_FILE_MODIFIED;
 
            /* Update the strucutres if the file size changed */
            if (FileSizeModified)
            {
                SharedCacheMap =
                    (PSHARED_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
                SharedCacheMap->FileSize.LowPart = NewSize.LowPart;
                FileObject->Flags |= FO_FILE_SIZE_CHANGED;
            }
 
            /* Update the file object current file offset */
            FileObject->CurrentByteOffset.QuadPart = NewSize.LowPart;
 
        }
        else
        {
            /* Result == FALSE if we get here */
            if (FileSizeModified)
            {
                /* If the file size was modified then restore the old file size */
                if (FcbHeader->PagingIoResource != NULL)
                {
                    /* Nagar P.544.
                     * Restore the old file size if operation didn't succeed.
                     */
                    ExAcquireResourceExclusiveLite(FcbHeader->PagingIoResource, TRUE);
                    FcbHeader->FileSize.LowPart = OldFileSize.LowPart;
                    FcbHeader->ValidDataLength.LowPart = OldValidDataLength.LowPart;
                    ExReleaseResourceLite(FcbHeader->PagingIoResource);
                }
                else
                {
                    /* If there is no lock and do it without */
                    FcbHeader->FileSize.LowPart = OldFileSize.LowPart;
                    FcbHeader->ValidDataLength.LowPart = OldValidDataLength.LowPart;
                }
            }
            else
            {
                /* Do nothing? */
            }
        }
 
        goto Cleanup;
    }
    else
    {
        LARGE_INTEGER OldFileSize;
 
        /* Sanity check */
        ASSERT(!KeIsExecutingDpc());
 
        /* Nagar P.544.
         * Check if we need to acquire the resource exclusive.
         */
        if ((FileOffsetAppend == FALSE) &&
            (FileOffset->QuadPart + Length <= FcbHeader->ValidDataLength.QuadPart))
        {
            /* Acquire the resource shared */
            if (!ExAcquireResourceSharedLite(FcbHeader->Resource, Wait))
            {
                goto LeaveCriticalAndFail;
            }
            ResourceAcquiredShared = TRUE;
        }
        else
        {
            /* Acquire the resource exclusive */
            if (!ExAcquireResourceExclusiveLite(FcbHeader->Resource, Wait))
            {
                goto LeaveCriticalAndFail;
            }
        }
 
        /* Check if we are appending */
        if (FileOffsetAppend != FALSE)
        {
            Offset.QuadPart = FcbHeader->FileSize.QuadPart;
            NewSize.QuadPart = FcbHeader->FileSize.QuadPart + Length;
        }
        else
        {
            Offset.QuadPart = FileOffset->QuadPart;
            NewSize.QuadPart += FileOffset->QuadPart + Length;
        }
 
        /* Nagar p.544/545.
         * Make sure that caching is initated.
         * That fast are allowed for this file stream.
         * That we are not extending past the allocated size.
         * That we are not creating a hole bigger than 8k.
         */
        if ((FileObject->PrivateCacheMap != NULL) &&
            (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
            (FcbHeader->ValidDataLength.QuadPart + 0x2000 > Offset.QuadPart) &&
            (Length <= MAXLONGLONG - Offset.QuadPart) &&
            (FcbHeader->AllocationSize.QuadPart >= NewSize.QuadPart))
        {
            /* Check if we can keep the lock shared */
            if (ResourceAcquiredShared &&
                (NewSize.QuadPart > FcbHeader->ValidDataLength.QuadPart))
            {
                ExReleaseResourceLite(FcbHeader->Resource);
                if (!ExAcquireResourceExclusiveLite(FcbHeader->Resource, Wait))
                {
                    goto LeaveCriticalAndFail;
                }
 
                /* Compute the offset and the new filesize */
                if (FileOffsetAppend)
                {
                    Offset.QuadPart = FcbHeader->FileSize.QuadPart;
                    NewSize.QuadPart = FcbHeader->FileSize.QuadPart + Length;
                }
 
                /* Recheck the above points since we released and reacquire the lock */
                if ((FileObject->PrivateCacheMap != NULL) &&
                    (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
                    (FcbHeader->AllocationSize.QuadPart > NewSize.QuadPart))
                {
                    /* Do nothing */
                }
                else
                {
                    goto FailAndCleanup;
                }
            }
 
            /* Check if we need to find out if fast I/O is available */
            if (FcbHeader->IsFastIoPossible == FastIoIsQuestionable)
            {
                IO_STATUS_BLOCK FastIoCheckIfPossibleStatus;
 
                /* Sanity check */
                ASSERT(!KeIsExecutingDpc());
 
                /* Get the Fast I/O table */
                Device = IoGetRelatedDeviceObject(FileObject);
                FastIoDispatch = Device->DriverObject->FastIoDispatch;
 
                /* Sanity check */
                ASSERT(FastIoDispatch != NULL);
                ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL);
 
                /* Ask the driver if we can do it */
                if (!FastIoDispatch->FastIoCheckIfPossible(FileObject,
                                                           FileOffsetAppend ?
                                                            &FcbHeader->FileSize :
                                                            FileOffset,
                                                           Length,
                                                           Wait,
                                                           LockKey,
                                                           FALSE,
                                                           &FastIoCheckIfPossibleStatus,
                                                           Device))
                {
                    /* It's not, fail */
                    goto FailAndCleanup;
                }
            }
 
            /* If we are going to modify the filesize,
             * save the old fs in case the operation fails.
             */
            if (NewSize.QuadPart > FcbHeader->FileSize.QuadPart)
            {
                FileSizeModified = TRUE;
                OldFileSize.QuadPart = FcbHeader->FileSize.QuadPart;
                OldValidDataLength.QuadPart = FcbHeader->ValidDataLength.QuadPart;
 
                /* If the high part of the filesize is going
                 * to change, grab the Paging IoResouce.
                 */
                if (NewSize.HighPart != FcbHeader->FileSize.HighPart &&
                    FcbHeader->PagingIoResource)
                {
                    ExAcquireResourceExclusiveLite(FcbHeader->PagingIoResource, TRUE);
                    FcbHeader->FileSize.QuadPart = NewSize.QuadPart;
                    ExReleaseResourceLite(FcbHeader->PagingIoResource);
                }
                else
                {
                    FcbHeader->FileSize.QuadPart = NewSize.QuadPart;
                }
            }
 
            /* Nagar p.544.
             * Set ourselves as top component.
             */
            PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP;
 
            _SEH2_TRY
            {
                BOOLEAN CallCc = TRUE;
 
                /* Check if there is a gap between the end of the file
                 * and the offset. If yes, then we have to zero the data.
                 */
                if (Offset.QuadPart > FcbHeader->ValidDataLength.QuadPart)
                {
                    if (!(Result = CcZeroData(FileObject,
                                              &FcbHeader->ValidDataLength,
                                              &Offset,
                                              Wait)))
                    {
                        /* If this operation fails, then we have to exit. We can't jump
                         * outside the SEH, so I am using a variable to exit normally.
                         */
                        CallCc = FALSE;
                    }
                }
 
                /* Unless the CcZeroData failed, call the cache manager */
                if (CallCc)
                {
                    Result = CcCopyWrite(FileObject, &Offset, Length, Wait, Buffer);
                }
            }
            _SEH2_EXCEPT(FsRtlIsNtstatusExpected(_SEH2_GetExceptionCode()) ?
                                                 EXCEPTION_EXECUTE_HANDLER :
                                                 EXCEPTION_CONTINUE_SEARCH)
            {
                Result = FALSE;
            }
            _SEH2_END;
 
            /* Reset the top component */
            PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP;
 
            /* Did the operation suceeded */
            if (Result)
            {
                /* Check if we need to update the filesize */
                if (NewSize.QuadPart > FcbHeader->ValidDataLength.QuadPart)
                {
                    if (NewSize.HighPart != FcbHeader->ValidDataLength.HighPart &&
                        FcbHeader->PagingIoResource)
                    {
                        ExAcquireResourceExclusiveLite(FcbHeader->PagingIoResource, TRUE);
                        FcbHeader->ValidDataLength.QuadPart = NewSize.QuadPart;
                        ExReleaseResourceLite(FcbHeader->PagingIoResource);
                    }
                    else
                    {
                        FcbHeader->ValidDataLength.QuadPart = NewSize.QuadPart;
                    }
                }
 
                /* Flag the file as modified */
                FileObject->Flags |= FO_FILE_MODIFIED;
 
                /* Check if the filesize has changed */
                if (FileSizeModified)
                {
                    /* Update the file sizes */
                    SharedCacheMap =
                        (PSHARED_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
                    SharedCacheMap->FileSize.QuadPart = NewSize.QuadPart;
                    FileObject->Flags |= FO_FILE_SIZE_CHANGED;
                }
 
                /* Update the current FO byte offset */
                FileObject->CurrentByteOffset.QuadPart = NewSize.QuadPart;
            }
            else
            {
                /* The operation did not succeed.
                 * Reset the file size to what it should be.
                 */
                if (FileSizeModified)
                {
                    if (FcbHeader->PagingIoResource)
                    {
                        ExAcquireResourceExclusiveLite(FcbHeader->PagingIoResource, TRUE);
                        FcbHeader->FileSize.QuadPart = OldFileSize.QuadPart;
                        FcbHeader->ValidDataLength.QuadPart = OldValidDataLength.QuadPart;
                        ExReleaseResourceLite(FcbHeader->PagingIoResource);
                    }
                    else
                    {
                        FcbHeader->FileSize.QuadPart = OldFileSize.QuadPart;
                        FcbHeader->ValidDataLength.QuadPart = OldValidDataLength.QuadPart;
                    }
                }
            }
 
            goto Cleanup;
        }
        else
        {
            goto FailAndCleanup;
        }
    }
 
LeaveCriticalAndFail:
 
    FsRtlExitFileSystem();
    return FALSE;
 
FailAndCleanup:
 
    ExReleaseResourceLite(FcbHeader->Resource);
    FsRtlExitFileSystem();
    return FALSE;
 
Cleanup:
 
    ExReleaseResourceLite(FcbHeader->Resource);
    FsRtlExitFileSystem();
    return Result;
}

Referenced by _Function_class_(), Ext2FastIoWrite(), FsRtlTest_StartTest(), and UDFFastIoCopyWrite().

FsRtlGetFileSize()

NTSTATUS NTAPI FsRtlGetFileSize	(	IN PFILE_OBJECT	FileObject,
		IN OUT PLARGE_INTEGER	FileSize
	)

Definition at line 815 of file fastio.c.

{
    FILE_STANDARD_INFORMATION Info;
    NTSTATUS Status;
    IO_STATUS_BLOCK IoStatus;
    PDEVICE_OBJECT DeviceObject;
    PFAST_IO_DISPATCH FastDispatch;
    KEVENT Event;
    PIO_STACK_LOCATION IoStackLocation;
    PIRP Irp;
    BOOLEAN OldHardError;
 
    PAGED_CODE();
 
    /* Get Device Object and Fast Calls */
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 
    /* Check if we support Fast Calls, and check FastIoQueryStandardInfo.
     * Call the function and see if it succeeds.
     */
    if (!FastDispatch ||
        !FastDispatch->FastIoQueryStandardInfo ||
        !FastDispatch->FastIoQueryStandardInfo(FileObject,
                                               TRUE,
                                               &Info,
                                               &IoStatus,
                                               DeviceObject))
    {
        /* If any of the above failed, then we are going to send an
         * IRP to the device object. Initialize the event for the IO.
         */
        KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
        /* Allocate the IRP */
        Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
 
        if (Irp == NULL)
        {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        /* Don't process hard error */
        OldHardError = IoSetThreadHardErrorMode(FALSE);
 
        /* Setup the IRP */
        Irp->UserIosb = &IoStatus;
        Irp->UserEvent = &Event;
        Irp->Tail.Overlay.Thread = PsGetCurrentThread();
        Irp->Flags = IRP_SYNCHRONOUS_PAGING_IO | IRP_PAGING_IO;
        Irp->RequestorMode = KernelMode;
        Irp->Tail.Overlay.OriginalFileObject = FileObject;
        Irp->AssociatedIrp.SystemBuffer = &Info;
 
        /* Setup out stack location */
        IoStackLocation = Irp->Tail.Overlay.CurrentStackLocation;
        IoStackLocation--;
        IoStackLocation->MajorFunction = IRP_MJ_QUERY_INFORMATION;
        IoStackLocation->FileObject = FileObject;
        IoStackLocation->DeviceObject = DeviceObject;
        IoStackLocation->Parameters.QueryFile.Length =
            sizeof(FILE_STANDARD_INFORMATION);
        IoStackLocation->Parameters.QueryFile.FileInformationClass =
            FileStandardInformation;
 
        /* Send the IRP to the related device object */
        Status = IoCallDriver(DeviceObject, Irp);
 
        /* Standard DDK IRP result processing */
        if (Status == STATUS_PENDING)
        {
            KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        }
 
        /* If there was a synchronous error, signal it */
        if (!NT_SUCCESS(Status))
        {
            IoStatus.Status = Status;
        }
 
        IoSetThreadHardErrorMode(OldHardError);
    }
 
    /* Check the sync/async IO result */
    if (NT_SUCCESS(IoStatus.Status))
    {
        /* Was the request for a directory? */
        if (Info.Directory)
        {
            IoStatus.Status = STATUS_FILE_IS_A_DIRECTORY;
        }
        else
        {
            FileSize->QuadPart = Info.EndOfFile.QuadPart;
        }
    }
 
    return IoStatus.Status;
}

Referenced by FsRtlTest_StartTest(), and MmCreateDataFileSection().

FsRtlIncrementCcFastReadNotPossible()

VOID NTAPI FsRtlIncrementCcFastReadNotPossible

(

VOID

)

Definition at line 34 of file fastio.c.

{
    CcFastReadNotPossible++;
}

FsRtlIncrementCcFastReadNoWait()

VOID NTAPI FsRtlIncrementCcFastReadNoWait

(

VOID

)

Definition at line 54 of file fastio.c.

{
    CcFastReadNoWait++;
}

FsRtlIncrementCcFastReadResourceMiss()

VOID NTAPI FsRtlIncrementCcFastReadResourceMiss

(

VOID

)

Definition at line 24 of file fastio.c.

{
    CcFastReadResourceMiss++;
}

Referenced by FsRtlCopyRead().

FsRtlIncrementCcFastReadWait()

VOID NTAPI FsRtlIncrementCcFastReadWait

(

VOID

)

Definition at line 44 of file fastio.c.

{
    CcFastReadWait++;
}

FsRtlMdlRead()

BOOLEAN NTAPI FsRtlMdlRead	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN ULONG	Length,
		IN ULONG	LockKey,
		OUT PMDL *	MdlChain,
		OUT PIO_STATUS_BLOCK	IoStatus
	)

Definition at line 921 of file fastio.c.

{
    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
    PFAST_IO_DISPATCH FastDispatch;
 
    /* Get Device Object and Fast Calls */
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 
    /* Check if we support Fast Calls, and check this one */
    if (FastDispatch && FastDispatch->MdlRead)
    {
        /* Use the fast path */
        return FastDispatch->MdlRead(FileObject,
                                     FileOffset,
                                     Length,
                                     LockKey,
                                     MdlChain,
                                     IoStatus,
                                     DeviceObject);
    }
 
    /* Get the Base File System (Volume) and Fast Calls */
    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
    FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
 
    /* If the Base Device Object has its own FastDispatch Routine, fail */
    if (FastDispatch && FastDispatch->MdlRead && BaseDeviceObject != DeviceObject)
    {
        return FALSE;
    }
 
    /* No fast path, use slow path */
    return FsRtlMdlReadDev(FileObject,
                           FileOffset,
                           Length,
                           LockKey,
                           MdlChain,
                           IoStatus,
                           DeviceObject);
}

Referenced by FsRtlTest_StartTest().

FsRtlMdlReadComplete()

BOOLEAN NTAPI FsRtlMdlReadComplete	(	IN PFILE_OBJECT	FileObject,
		IN OUT PMDL	MdlChain
	)

Definition at line 973 of file fastio.c.

{
    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
    PFAST_IO_DISPATCH FastDispatch;
 
    /* Get Device Object and Fast Calls */
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 
    /* Check if we support Fast Calls, and check this one */
    if (FastDispatch && FastDispatch->MdlReadComplete)
    {
        /* Use the fast path */
        return FastDispatch->MdlReadComplete(FileObject, MdlChain, DeviceObject);
    }
 
    /* Get the Base File System (Volume) and Fast Calls */
    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
    FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
 
    /* If the Base Device Object has its own FastDispatch Routine, fail */
    if ((BaseDeviceObject != DeviceObject) &&
        FastDispatch &&
        FastDispatch->MdlReadComplete)
    {
        return FALSE;
    }
 
    /* No fast path, use slow path */
    return FsRtlMdlReadCompleteDev(FileObject, MdlChain, DeviceObject);
}

Referenced by FsRtlTest_StartTest().

FsRtlMdlReadCompleteDev()

BOOLEAN NTAPI FsRtlMdlReadCompleteDev	(	IN PFILE_OBJECT	FileObject,
		IN PMDL	MemoryDescriptorList,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 1011 of file fastio.c.

{
    /* Call the Cache Manager */
    CcMdlReadComplete2(FileObject, MemoryDescriptorList);
    return TRUE;
}

Referenced by CdInitializeGlobalData(), FsRtlMdlReadComplete(), FsRtlTest_StartTest(), and init_fast_io_dispatch().

FsRtlMdlReadDev()

BOOLEAN NTAPI FsRtlMdlReadDev	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN ULONG	Length,
		IN ULONG	LockKey,
		OUT PMDL *	MdlChain,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 1025 of file fastio.c.

{
    PFSRTL_COMMON_FCB_HEADER FcbHeader;
    BOOLEAN Result = TRUE;
    LARGE_INTEGER Offset;
    PFAST_IO_DISPATCH FastIoDispatch;
    PDEVICE_OBJECT Device;
    PAGED_CODE();
 
    /* No actual read */
    if (!Length)
    {
        /* Return success */
        IoStatus->Status = STATUS_SUCCESS;
        IoStatus->Information = 0;
        return TRUE;
    }
 
    /* Sanity check */
    ASSERT(MAXLONGLONG - FileOffset->QuadPart >= (LONGLONG)Length);
 
    /* Get the offset and FCB header */
    Offset.QuadPart = FileOffset->QuadPart + Length;
    FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
 
    /* Enter the FS */
    FsRtlEnterFileSystem();
    CcFastMdlReadWait++;
 
    /* Lock the FCB */
    ExAcquireResourceShared(FcbHeader->Resource, TRUE);
 
    /* Check if this is a fast I/O cached file */
    if (!(FileObject->PrivateCacheMap) ||
        (FcbHeader->IsFastIoPossible == FastIoIsNotPossible))
    {
        /* It's not, so fail */
        CcFastMdlReadNotPossible += 1;
        Result = FALSE;
        goto Cleanup;
    }
 
    /* Check if we need to find out if fast I/O is available */
    if (FcbHeader->IsFastIoPossible == FastIoIsQuestionable)
    {
        /* Get the Fast I/O table */
        Device = IoGetRelatedDeviceObject(FileObject);
        FastIoDispatch = Device->DriverObject->FastIoDispatch;
 
        /* Sanity check */
        ASSERT(!KeIsExecutingDpc());
        ASSERT(FastIoDispatch != NULL);
        ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL);
 
        /* Ask the driver if we can do it */
        if (!FastIoDispatch->FastIoCheckIfPossible(FileObject,
                                                   FileOffset,
                                                   Length,
                                                   TRUE,
                                                   LockKey,
                                                   TRUE,
                                                   IoStatus,
                                                   Device))
        {
            /* It's not, fail */
            CcFastMdlReadNotPossible += 1;
            Result = FALSE;
            goto Cleanup;
        }
    }
 
    /* Check if we read too much */
    if (Offset.QuadPart > FcbHeader->FileSize.QuadPart)
    {
        /* We did, check if the file offset is past the end */
        if (FileOffset->QuadPart >= FcbHeader->FileSize.QuadPart)
        {
            /* Set end of file */
            IoStatus->Status = STATUS_END_OF_FILE;
            IoStatus->Information = 0;
            goto Cleanup;
        }
 
        /* Otherwise, just normalize the length */
        Length = (ULONG)(FcbHeader->FileSize.QuadPart - FileOffset->QuadPart);
    }
 
    /* Set this as top-level IRP */
    PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP;
 
    _SEH2_TRY
    {
        /* Attempt a read */
        CcMdlRead(FileObject, FileOffset, Length, MdlChain, IoStatus);
        FileObject->Flags |= FO_FILE_FAST_IO_READ;
    }
    _SEH2_EXCEPT(FsRtlIsNtstatusExpected(_SEH2_GetExceptionCode()) ?
                                         EXCEPTION_EXECUTE_HANDLER :
                                         EXCEPTION_CONTINUE_SEARCH)
    {
        Result = FALSE;
    }
    _SEH2_END;
 
 
    /* Remove the top-level IRP flag */
    PsGetCurrentThread()->TopLevelIrp = 0;
 
    /* Return to caller */
Cleanup:
 
    ExReleaseResourceLite(FcbHeader->Resource);
    FsRtlExitFileSystem();
 
    return Result;
}

Referenced by CdInitializeGlobalData(), FsRtlMdlRead(), FsRtlTest_StartTest(), and init_fast_io_dispatch().

FsRtlMdlWriteComplete()

BOOLEAN NTAPI FsRtlMdlWriteComplete	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN PMDL	MdlChain
	)

Definition at line 1153 of file fastio.c.

{
    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
    PFAST_IO_DISPATCH FastDispatch;
 
    /* Get Device Object and Fast Calls */
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 
    /* Check if we support Fast Calls, and check this one */
    if (FastDispatch && FastDispatch->MdlWriteComplete)
    {
        /* Use the fast path */
        return FastDispatch->MdlWriteComplete(FileObject,
                                              FileOffset,
                                              MdlChain,
                                              DeviceObject);
    }
 
    /* Get the Base File System (Volume) and Fast Calls */
    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
    FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
 
    /* If the Base Device Object has its own FastDispatch Routine, fail */
    if (FastDispatch &&
        FastDispatch->MdlWriteComplete &&
        BaseDeviceObject != DeviceObject)
    {
        return FALSE;
    }
 
    /* No fast path, use slow path */
    return FsRtlMdlWriteCompleteDev(FileObject,
                                    FileOffset,
                                    MdlChain,
                                    DeviceObject);
}

Referenced by FsRtlTest_StartTest().

FsRtlMdlWriteCompleteDev()

BOOLEAN NTAPI FsRtlMdlWriteCompleteDev	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN PMDL	MdlChain,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 1198 of file fastio.c.

{
    if (FileObject->Flags & FO_WRITE_THROUGH)
    {
        return FALSE;
    }
 
    /* Call the Cache Manager */
    CcMdlWriteComplete2(FileObject, FileOffset, MdlChain);
    return TRUE;
}

Referenced by CdInitializeGlobalData(), FsRtlMdlWriteComplete(), FsRtlTest_StartTest(), and init_fast_io_dispatch().

FsRtlpGetResourceForModWrite()

static BOOLEAN FsRtlpGetResourceForModWrite ( _In_ PFSRTL_COMMON_FCB_HEADER  FcbHeader, _In_ PLARGE_INTEGER  EndingOffset, _Outptr_result_maybenull_ PERESOURCE *  ResourceToAcquire  )

static

Get the resource to acquire when Mod Writer flushes data to disk.

Parameters

FcbHeader	- FCB header from the file object
EndingOffset	- The end offset of the write to be done
ResourceToAcquire	- Pointer receiving the resource to acquire before doing the write

Returns

BOOLEAN specifying whether the resource must be acquired exclusively

Definition at line 1815 of file fastio.c.

{
    /*
     * Decide on type of locking and type of resource based on
     *  - Flags
     *  - Whether we're extending ValidDataLength
     */
    if (FlagOn(FcbHeader->Flags, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_EX))
    {
        /* Acquire main resource, exclusive */
        *ResourceToAcquire = FcbHeader->Resource;
        return TRUE;
    }
 
    /* We will acquire shared. Which one ? */
    if (FlagOn(FcbHeader->Flags, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH))
    {
        *ResourceToAcquire = FcbHeader->Resource;
    }
    else
    {
        *ResourceToAcquire = FcbHeader->PagingIoResource;
    }
 
    /* We force exclusive lock if this write modifies the valid data length */
    return (EndingOffset->QuadPart > FcbHeader->ValidDataLength.QuadPart);
}

Referenced by FsRtlAcquireFileForModWriteEx().

FsRtlPrepareMdlWrite()

BOOLEAN NTAPI FsRtlPrepareMdlWrite	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN ULONG	Length,
		IN ULONG	LockKey,
		OUT PMDL *	MdlChain,
		OUT PIO_STATUS_BLOCK	IoStatus
	)

Definition at line 1218 of file fastio.c.

{
    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
    PFAST_IO_DISPATCH FastDispatch;
 
    /* Get Device Object and Fast Calls */
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 
    /* Check if we support Fast Calls, and check this one */
    if (FastDispatch && FastDispatch->PrepareMdlWrite)
    {
        /* Use the fast path */
        return FastDispatch->PrepareMdlWrite(FileObject,
                                             FileOffset,
                                             Length,
                                             LockKey,
                                             MdlChain,
                                             IoStatus,
                                             DeviceObject);
    }
 
    /* Get the Base File System (Volume) and Fast Calls */
    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
    FastDispatch = BaseDeviceObject->DriverObject->FastIoDispatch;
 
    /* If the Base Device Object has its own FastDispatch Routine, fail */
    if (FastDispatch &&
        FastDispatch->PrepareMdlWrite &&
        BaseDeviceObject != DeviceObject)
    {
        return FALSE;
    }
 
    /* No fast path, use slow path */
    return FsRtlPrepareMdlWriteDev(FileObject,
                                   FileOffset,
                                   Length,
                                   LockKey,
                                   MdlChain,
                                   IoStatus,
                                   DeviceObject);
}

Referenced by FsRtlTest_StartTest().

FsRtlPrepareMdlWriteDev()

BOOLEAN NTAPI FsRtlPrepareMdlWriteDev	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN ULONG	Length,
		IN ULONG	LockKey,
		OUT PMDL *	MdlChain,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 1272 of file fastio.c.

{
    BOOLEAN Result = TRUE;
    PFAST_IO_DISPATCH FastIoDispatch;
    PDEVICE_OBJECT Device;
    PFSRTL_COMMON_FCB_HEADER FcbHeader;
    PSHARED_CACHE_MAP SharedCacheMap;
 
    LARGE_INTEGER OldFileSize;
    LARGE_INTEGER OldValidDataLength;
    LARGE_INTEGER NewSize;
    LARGE_INTEGER Offset;
 
    /* WDK doc.
     * Offset == 0xffffffffffffffff indicates append to the end of file.
     */
    BOOLEAN FileOffsetAppend = (FileOffset->HighPart == (LONG)0xffffffff) &&
                               (FileOffset->LowPart == 0xffffffff);
 
    BOOLEAN FileSizeModified = FALSE;
    BOOLEAN ResourceAcquiredShared = FALSE;
 
    /* Initialize some of the vars and pointers */
    OldFileSize.QuadPart = 0;
    OldValidDataLength.QuadPart = 0;
 
    PAGED_CODE();
 
    Offset.QuadPart = FileOffset->QuadPart + Length;
 
    /* Nagar p.544.
     * Check with Cc if we can write.
     */
    if (!CcCanIWrite(FileObject, Length, TRUE, FALSE) ||
        (FileObject->Flags & FO_WRITE_THROUGH))
    {
        return FALSE;
    }
 
    IoStatus->Status = STATUS_SUCCESS;
 
    /* No actual read */
    if (!Length)
    {
        return TRUE;
    }
 
    FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
    FsRtlEnterFileSystem();
 
    /* Check we are going to extend the file */
    if ((FileOffsetAppend == FALSE) &&
        (FileOffset->QuadPart + Length <= FcbHeader->ValidDataLength.QuadPart))
    {
        /* Acquire the resource shared */
        ExAcquireResourceSharedLite(FcbHeader->Resource, TRUE);
        ResourceAcquiredShared = TRUE;
    }
    else
    {
        /* Acquire the resource exclusive */
        ExAcquireResourceExclusiveLite(FcbHeader->Resource, TRUE);
    }
 
    /* Check if we are appending */
    if (FileOffsetAppend != FALSE)
    {
        Offset.QuadPart = FcbHeader->FileSize.QuadPart;
        NewSize.QuadPart = FcbHeader->FileSize.QuadPart + Length;
    }
    else
    {
        Offset.QuadPart = FileOffset->QuadPart;
        NewSize.QuadPart = FileOffset->QuadPart + Length;
    }
 
    if ((FileObject->PrivateCacheMap) &&
        (FcbHeader->IsFastIoPossible) &&
        (Length <= MAXLONGLONG - FileOffset->QuadPart) &&
        (NewSize.QuadPart <= FcbHeader->AllocationSize.QuadPart))
    {
        /* Check if we can keep the lock shared */
        if (ResourceAcquiredShared &&
            (NewSize.QuadPart > FcbHeader->ValidDataLength.QuadPart))
        {
            ExReleaseResourceLite(FcbHeader->Resource);
            ExAcquireResourceExclusiveLite(FcbHeader->Resource, TRUE);
 
            /* Compute the offset and the new filesize */
            if (FileOffsetAppend)
            {
                Offset.QuadPart = FcbHeader->FileSize.QuadPart;
                NewSize.QuadPart = FcbHeader->FileSize.QuadPart + Length;
            }
 
            /* Recheck the above points since we released and reacquire the lock */
            if ((FileObject->PrivateCacheMap != NULL) &&
                (FcbHeader->IsFastIoPossible != FastIoIsNotPossible) &&
                (FcbHeader->AllocationSize.QuadPart > NewSize.QuadPart))
            {
                /* Do nothing */
            }
            else
            {
                goto FailAndCleanup;
            }
        }
 
        /* Check if we need to find out if fast I/O is available */
        if (FcbHeader->IsFastIoPossible == FastIoIsQuestionable)
        {
            /* Sanity check */
            /* ASSERT(!KeIsExecutingDpc()); */
 
            /* Get the Fast I/O table */
            Device = IoGetRelatedDeviceObject(FileObject);
            FastIoDispatch = Device->DriverObject->FastIoDispatch;
 
            /* Sanity check */
            ASSERT(FastIoDispatch != NULL);
            ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL);
 
            /* Ask the driver if we can do it */
            if (!FastIoDispatch->FastIoCheckIfPossible(FileObject,
                                                       FileOffset,
                                                       Length,
                                                       TRUE,
                                                       LockKey,
                                                       FALSE,
                                                       IoStatus,
                                                       Device))
            {
                /* It's not, fail */
                goto FailAndCleanup;
            }
        }
 
        /* If we are going to modify the filesize,
         * save the old fs in case the operation fails.
         */
        if (NewSize.QuadPart > FcbHeader->FileSize.QuadPart)
        {
            FileSizeModified = TRUE;
            OldFileSize.QuadPart = FcbHeader->FileSize.QuadPart;
            OldValidDataLength.QuadPart = FcbHeader->ValidDataLength.QuadPart;
 
            /* If the high part of the filesize is going
             * to change, grab the Paging IoResouce.
             */
            if (NewSize.HighPart != FcbHeader->FileSize.HighPart &&
                FcbHeader->PagingIoResource)
            {
                ExAcquireResourceExclusiveLite(FcbHeader->PagingIoResource, TRUE);
                FcbHeader->FileSize.QuadPart = NewSize.QuadPart;
                ExReleaseResourceLite(FcbHeader->PagingIoResource);
            }
            else
            {
                FcbHeader->FileSize.QuadPart = NewSize.QuadPart;
            }
        }
 
 
        /* Nagar p.544.
         * Set ourselves as top component.
         */
        PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP;
        _SEH2_TRY
        {
            /* Check if there is a gap between the end of the file and the offset.
             * If yes, then we have to zero the data.
             */
            if (Offset.QuadPart > FcbHeader->ValidDataLength.QuadPart)
            {
                Result = CcZeroData(FileObject,
                                    &FcbHeader->ValidDataLength,
                                    &Offset,
                                    TRUE);
                if (Result)
                {
                    CcPrepareMdlWrite(FileObject,
                                      &Offset,
                                      Length,
                                      MdlChain,
                                      IoStatus);
                }
            }
            else
            {
                CcPrepareMdlWrite(FileObject, &Offset, Length, MdlChain, IoStatus);
            }
 
        }
        _SEH2_EXCEPT(FsRtlIsNtstatusExpected(_SEH2_GetExceptionCode()) ?
                                             EXCEPTION_EXECUTE_HANDLER :
                                             EXCEPTION_CONTINUE_SEARCH)
        {
            Result = FALSE;
        }
        _SEH2_END;
 
        /* Reset the top component */
        PsGetCurrentThread()->TopLevelIrp = 0;
 
        /* Did the operation suceeded */
        if (Result)
        {
            /* Check if we need to update the filesize */
            if (NewSize.QuadPart > FcbHeader->ValidDataLength.QuadPart)
            {
                if (NewSize.HighPart != FcbHeader->ValidDataLength.HighPart &&
                    FcbHeader->PagingIoResource)
                {
                    ExAcquireResourceExclusiveLite(FcbHeader->PagingIoResource, TRUE);
                    FcbHeader->ValidDataLength.QuadPart = NewSize.QuadPart;
                    ExReleaseResourceLite(FcbHeader->PagingIoResource);
                }
                else
                {
                    FcbHeader->ValidDataLength.QuadPart = NewSize.QuadPart;
                }
            }
 
            /* Flag the file as modified */
            FileObject->Flags |= FO_FILE_MODIFIED;
 
            /* Check if the filesize has changed */
            if (FileSizeModified)
            {
                SharedCacheMap =
                    (PSHARED_CACHE_MAP)FileObject->SectionObjectPointer->SharedCacheMap;
                SharedCacheMap->FileSize.QuadPart = NewSize.QuadPart;
                FileObject->Flags |= FO_FILE_SIZE_CHANGED;
            }
        }
        else
        {
            /* The operation did not succeed.
             * Reset the file size to what it should be.
             */
            if (FileSizeModified)
            {
                if (FcbHeader->PagingIoResource)
                {
                    ExAcquireResourceExclusiveLite(FcbHeader->PagingIoResource, TRUE);
                    FcbHeader->FileSize.QuadPart = OldFileSize.QuadPart;
                    FcbHeader->ValidDataLength.QuadPart = OldValidDataLength.QuadPart;
                    ExReleaseResourceLite(FcbHeader->PagingIoResource);
                }
                else
                {
                    FcbHeader->FileSize.QuadPart = OldFileSize.QuadPart;
                    FcbHeader->ValidDataLength.QuadPart = OldValidDataLength.QuadPart;
                }
            }
        }
 
        goto Cleanup;
    }
    else
    {
        goto FailAndCleanup;
    }
 
FailAndCleanup:
 
    ExReleaseResourceLite(FcbHeader->Resource);
    FsRtlExitFileSystem();
    return FALSE;
 
Cleanup:
 
    ExReleaseResourceLite(FcbHeader->Resource);
    FsRtlExitFileSystem();
    return Result;
}

Referenced by CdInitializeGlobalData(), FsRtlPrepareMdlWrite(), FsRtlTest_StartTest(), and init_fast_io_dispatch().

FsRtlRegisterFileSystemFilterCallbacks()

NTSTATUS NTAPI FsRtlRegisterFileSystemFilterCallbacks	(	PDRIVER_OBJECT	FilterDriverObject,
		PFS_FILTER_CALLBACKS	Callbacks
	)

Definition at line 2014 of file fastio.c.

{
    PFS_FILTER_CALLBACKS NewCallbacks;
    PEXTENDED_DRIVER_EXTENSION DriverExtension;
    PAGED_CODE();
 
    /* Verify parameters */
    if ((FilterDriverObject == NULL) || (Callbacks == NULL))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Allocate a buffer for a copy of the callbacks */
    NewCallbacks = ExAllocatePoolWithTag(NonPagedPool,
                                         Callbacks->SizeOfFsFilterCallbacks,
                                         'gmSF');
    if (NewCallbacks == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Copy the callbacks */
    RtlCopyMemory(NewCallbacks, Callbacks, Callbacks->SizeOfFsFilterCallbacks);
 
    /* Set the callbacks in the driver extension */
    DriverExtension = (PEXTENDED_DRIVER_EXTENSION)FilterDriverObject->DriverExtension;
    DriverExtension->FsFilterCallbacks = NewCallbacks;
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry(), and SetupDispatchAndCallbacksTables().

FsRtlReleaseFile()

VOID NTAPI FsRtlReleaseFile

(

IN PFILE_OBJECT

FileObject

)

Definition at line 1665 of file fastio.c.

{
    PFSRTL_COMMON_FCB_HEADER FcbHeader;
    PDEVICE_OBJECT DeviceObject;
    PFAST_IO_DISPATCH FastDispatch;
 
    /* Get Device Object and Fast Calls */
    FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 
    /* Check if Fast Calls are supported and check ReleaseFileForNtCreateSection */
    if (FastDispatch &&
        FastDispatch->ReleaseFileForNtCreateSection)
    {
        /* Call the ReleaseFileForNtCreateSection FastIo handler */
        FastDispatch->ReleaseFileForNtCreateSection(FileObject);
    }
    else
    {
        /* No FastIo handler, release file's resource */
        if (FcbHeader && FcbHeader->Resource) ExReleaseResourceLite(FcbHeader->Resource);
    }
 
    /* Release master FsRtl lock */
    FsRtlExitFileSystem();
}

Referenced by MiRosUnmapViewOfSection(), MmCreateSection(), and MmNotPresentFaultSectionView().

FsRtlReleaseFileForCcFlush()

VOID NTAPI FsRtlReleaseFileForCcFlush

(

IN PFILE_OBJECT

FileObject

)

Definition at line 1771 of file fastio.c.

{
    PFSRTL_COMMON_FCB_HEADER FcbHeader;
    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
    PFAST_IO_DISPATCH FastDispatch;
    NTSTATUS Status = STATUS_INVALID_DEVICE_REQUEST;
 
    /* Get Device Object and Fast Calls */
    FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 
    /* Check if Fast Calls are supported, and check ReleaseForCcFlush */
    if (FastDispatch &&
        FastDispatch->ReleaseForCcFlush)
    {
        /* Call the ReleaseForCcFlush FastIo handler */
        Status = FastDispatch->ReleaseForCcFlush(FileObject, BaseDeviceObject);
    }
 
    if (!NT_SUCCESS(Status))
    {
        /* No FastIo handler (or it failed). Release PagingIO resource and
           then Main resource */
        if (FcbHeader->PagingIoResource) ExReleaseResourceLite(FcbHeader->PagingIoResource);
        if (FcbHeader->Resource) ExReleaseResourceLite(FcbHeader->Resource);
    }
 
    /* Release master FsRtl lock */
    FsRtlExitFileSystem();
}

Referenced by CcRosFlushVacb().

FsRtlReleaseFileForModWrite()

VOID NTAPI FsRtlReleaseFileForModWrite	(	_In_ PFILE_OBJECT	FileObject,
		_In_ PERESOURCE	ResourceToRelease
	)

Unlock a file object after flushing pages to disk. To be called by the Modified Page Writer (MPW) after a succesful call to FsRtlAcquireFileForModWriteEx.

Parameters

FileObject	- The file object to unlock
ResourceToRelease	- The resource to release

Definition at line 1965 of file fastio.c.

{
    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
    PFAST_IO_DISPATCH FastDispatch;
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
 
    /* Get Device Object and Fast Calls */
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 
    /* Check if Fast Calls are supported and check ReleaseForModWrite */
    if (FastDispatch &&
        FastDispatch->ReleaseForModWrite)
    {
        /* Call the ReleaseForModWrite FastIo handler */
        Status = FastDispatch->ReleaseForModWrite(FileObject,
                                                  ResourceToRelease,
                                                  BaseDeviceObject);
    }
 
    /* Just release the resource if previous op failed */
    if (!NT_SUCCESS(Status))
    {
        ExReleaseResourceLite(ResourceToRelease);
    }
}