fastio.c File Reference

#include "FsRtlP.h"

Go to the source code of this file.

Defines
#define	Dbg   (0x04000000)
Functions
BOOLEAN	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	FsRtlCopyWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, IN PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
BOOLEAN	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	FsRtlMdlRead (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG LockKey, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
BOOLEAN	FsRtlMdlReadComplete (IN PFILE_OBJECT FileObject, IN PMDL MdlChain)
BOOLEAN	FsRtlMdlReadCompleteDev (IN PFILE_OBJECT FileObject, IN PMDL MdlChain, IN PDEVICE_OBJECT DeviceObject)
BOOLEAN	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)
BOOLEAN	FsRtlPrepareMdlWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG LockKey, OUT PMDL *MdlChain, OUT PIO_STATUS_BLOCK IoStatus)
BOOLEAN	FsRtlMdlWriteComplete (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PMDL MdlChain)
BOOLEAN	FsRtlMdlWriteCompleteDev (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PMDL MdlChain, IN PDEVICE_OBJECT DeviceObject)
NTKERNELAPI BOOLEAN	FsRtlAcquireFileForModWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER EndingOffset, OUT PERESOURCE *ResourceToRelease)
NTKERNELAPI VOID	FsRtlReleaseFileForModWrite (IN PFILE_OBJECT FileObject, IN PERESOURCE ResourceToRelease)
NTKERNELAPI VOID	FsRtlAcquireFileForCcFlush (IN PFILE_OBJECT FileObject)
NTKERNELAPI VOID	FsRtlReleaseFileForCcFlush (IN PFILE_OBJECT FileObject)
NTKERNELAPI VOID	FsRtlAcquireFileExclusive (IN PFILE_OBJECT FileObject)
NTKERNELAPI VOID	FsRtlReleaseFile (IN PFILE_OBJECT FileObject)
NTSTATUS	FsRtlGetFileSize (IN PFILE_OBJECT FileObject, IN OUT PLARGE_INTEGER FileSize)
NTSTATUS	FsRtlSetFileSize (IN PFILE_OBJECT FileObject, IN OUT PLARGE_INTEGER FileSize)

---

Define Documentation

#define Dbg   (0x04000000)

Definition at line 31 of file fastio.c.

---

Function Documentation

NTKERNELAPI VOID FsRtlAcquireFileExclusive (  IN PFILE_OBJECT  FileObject  )

Definition at line 2555 of file fastio.c. References _FAST_IO_DISPATCH::AcquireFileForNtCreateSection, _DEVICE_OBJECT::DriverObject, ExAcquireResourceExclusive, _DRIVER_OBJECT::FastIoDispatch, FsRtlEnterFileSystem, Header, IoGetBaseFileSystemDeviceObject(), NULL, PAGED_CODE, _FAST_IO_DISPATCH::SizeOfFastIoDispatch, and TRUE. Referenced by CcWriteBehind(), CcZeroEndOfLastPage(), and MmCreateSection(). 02561 : 02562 02563 This routine is used by NtCreateSection to pre-acquire file system 02564 resources in order to avoid deadlocks. If there is a FastIo entry 02565 for AcquireFileForNtCreateSection then that routine will be called. 02566 Otherwise, we will simply acquire the main file resource exclusive. 02567 If there is no main resource then we acquire nothing and return 02568 FALSE. In the cases that we acquire a resource, we also set the 02569 TopLevelIrp field in the thread local storage to indicate to file 02570 systems beneath us that we have acquired file system resources. 02571 02572 Arguments: 02573 02574 FileObject - Pointer to the file object being written. 02575 02576 Return Value: 02577 02578 NONE 02579 02580 --*/ 02581 02582 { 02583 PDEVICE_OBJECT DeviceObject; 02584 PFAST_IO_DISPATCH FastIoDispatch; 02585 PFSRTL_COMMON_FCB_HEADER Header; 02586 02587 PAGED_CODE(); 02588 02589 // 02590 // First see if we have to call the file system. 02591 // 02592 02593 DeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); 02594 02595 if ((FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch) && 02596 (FastIoDispatch->SizeOfFastIoDispatch > 02597 FIELD_OFFSET( FAST_IO_DISPATCH, AcquireFileForNtCreateSection )) && 02598 (FastIoDispatch->AcquireFileForNtCreateSection != NULL)) { 02599 02600 FsRtlEnterFileSystem(); 02601 FastIoDispatch->AcquireFileForNtCreateSection( FileObject ); 02602 02603 return; 02604 } 02605 02606 // 02607 // If there is a main file resource, acquire that. 02608 // 02609 02610 if ((Header = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext) && 02611 (Header->Resource != NULL)) { 02612 02613 FsRtlEnterFileSystem(); 02614 ExAcquireResourceExclusive( Header->Resource, TRUE ); 02615 02616 return; 02617 } 02618 02619 // 02620 // Nothing to acquire. 02621 // 02622 02623 return; 02624 }

NTKERNELAPI VOID FsRtlAcquireFileForCcFlush (  IN PFILE_OBJECT  FileObject  )

Definition at line 2402 of file fastio.c. References _FAST_IO_DISPATCH::AcquireForCcFlush, ASSERT, _DEVICE_OBJECT::DriverObject, ExAcquireResourceExclusive, ExAcquireResourceShared, ExIsResourceAcquiredShared, _DRIVER_OBJECT::FastIoDispatch, FsRtlEnterFileSystem, Header, IoGetBaseFileSystemDeviceObject(), NTSTATUS(), NULL, PAGED_CODE, _FAST_IO_DISPATCH::SizeOfFastIoDispatch, Status, and TRUE. Referenced by MiRemoveUnusedSegments(), MmFlushSection(), and MmFlushVirtualMemory(). : This routine acquires a file system resource prior to a call to CcFlush. Arguments: FileObject - Pointer to the file object being written. Return Value: None. --*/ { PDEVICE_OBJECT DeviceObject; PFAST_IO_DISPATCH FastIoDispatch; NTSTATUS Status = STATUS_INVALID_DEVICE_REQUEST; PAGED_CODE(); // // First see if we have to call the file system. Note that in the case // of layered file systems, the layered file system might have the // dispatch routine, but the file system on which it is layered on may // not. In that case, the layered file system will return // STATUS_INVALID_DEVICE_REQUEST. // DeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); FsRtlEnterFileSystem(); if ((FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET( FAST_IO_DISPATCH, AcquireForCcFlush )) && (FastIoDispatch->AcquireForCcFlush != NULL)) { Status = FastIoDispatch->AcquireForCcFlush( FileObject, DeviceObject ); } ASSERT( (Status == STATUS_SUCCESS) || (Status == STATUS_INVALID_DEVICE_REQUEST) ); if (Status == STATUS_INVALID_DEVICE_REQUEST) { PFSRTL_COMMON_FCB_HEADER Header = FileObject->FsContext; // // If not already owned get the main resource exclusive because me may // extend ValidDataLength. Otherwise acquire it one more time recursively. // if (Header->Resource != NULL) { if (!ExIsResourceAcquiredShared(Header->Resource)) { ExAcquireResourceExclusive( Header->Resource, TRUE ); } else { ExAcquireResourceShared( Header->Resource, TRUE ); } } // // Also get the paging I/O resource ahead of any MM resources. // if (Header->PagingIoResource != NULL) { ExAcquireResourceShared( Header->PagingIoResource, TRUE ); } } }

NTKERNELAPI BOOLEAN FsRtlAcquireFileForModWrite (  IN PFILE_OBJECT  FileObject, IN PLARGE_INTEGER  EndingOffset, OUT PERESOURCE *  ResourceToRelease )

Definition at line 2064 of file fastio.c. References AcquireExclusive, _FAST_IO_DISPATCH::AcquireForModWrite, _DEVICE_OBJECT::DriverObject, ExAcquireResourceExclusive, ExAcquireSharedWaitForExclusive(), ExConvertExclusiveToShared, ExReleaseResource, FALSE, _DRIVER_OBJECT::FastIoDispatch, FlagOn, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_EX, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH, Header, IoGetBaseFileSystemDeviceObject(), NTSTATUS(), NULL, PAGED_CODE, _FAST_IO_DISPATCH::SizeOfFastIoDispatch, Status, and TRUE. Referenced by MiGatherMappedPages(), and MiMappedPageWriter(). : This routine decides which file system resource the modified page writer should acquire and acquires it if possible. Wait is always specified as FALSE. We pass back the resource Mm has to release when the write completes. Arguments: FileObject - Pointer to the file object being written. EndingOffset - The offset of the last byte being written + 1. ByteCount - Length of data in bytes. ResourceToRelease - Returns the resource to release. Not defined if FALSE is returned. Return Value: FALSE - The resource could not be acquired without waiting. TRUE - The returned resource has been acquired. --*/ { PFSRTL_COMMON_FCB_HEADER Header; PERESOURCE ResourceAcquired; PDEVICE_OBJECT DeviceObject; PFAST_IO_DISPATCH FastIoDispatch; BOOLEAN AcquireExclusive; PAGED_CODE(); Header = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext; // // First see if we have to call the file system. // DeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; if ((FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET( FAST_IO_DISPATCH, AcquireForModWrite )) && (FastIoDispatch->AcquireForModWrite != NULL)) { NTSTATUS Status; Status = FastIoDispatch->AcquireForModWrite(FileObject, EndingOffset, ResourceToRelease, DeviceObject); if (Status == STATUS_SUCCESS) { return( TRUE ); } else if (Status == STATUS_CANT_WAIT) { return( FALSE ); } else { // // Fall through. When dealing with layered file systems, it might // be the case that the layered file system has the above dispatch // routine, but the FS it is layered on top of does not. In that // case, the layered file system will return an error code other // than STATUS_SUCCESS or STATUS_CANT_WAIT, and we simply handle // it as if the file system did not have the dispatch routine to // begin with. // NOTHING; } } // // We follow the following rules to determine which resource // to acquire. We use the flags in the common header. These // flags can't change once we have acquired any resource. // This means we can do an unsafe test and optimisticly // acquire a resource. At that point we can test the bits // to see if we have what we want. // // 0 - If there is no main resource, acquire nothing. // // 1 - Acquire the main resource exclusively if the // ACQUIRE_MAIN_RSRC_EX flag is set or we are extending // valid data. // // 2 - Acquire the main resource shared if there is // no paging io resource or the // ACQUIRE_MAIN_RSRC_SH flag is set. // // 3 - Otherwise acquire the paging io resource shared. // if (Header->Resource == NULL) { *ResourceToRelease = NULL; return TRUE; } if (FlagOn( Header->Flags, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_EX ) || (EndingOffset->QuadPart > Header->ValidDataLength.QuadPart && Header->ValidDataLength.QuadPart != Header->FileSize.QuadPart)) { ResourceAcquired = Header->Resource; AcquireExclusive = TRUE; } else if (FlagOn( Header->Flags, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH ) || Header->PagingIoResource == NULL) { ResourceAcquired = Header->Resource; AcquireExclusive = FALSE; } else { ResourceAcquired = Header->PagingIoResource; AcquireExclusive = FALSE; } // // Perform the following in a loop in case we need to back and // check the state of the resource acquisition. In most cases // the initial checks will succeed and we can proceed immediately. // We have to worry about the two FsRtl bits changing but // if there is no paging io resource before there won't ever be // one. // while (TRUE) { // // Now acquire the desired resource. // if (AcquireExclusive) { if (!ExAcquireResourceExclusive( ResourceAcquired, FALSE )) { return FALSE; } } else if (!ExAcquireSharedWaitForExclusive( ResourceAcquired, FALSE )) { return FALSE; } // // If the valid data length is changing or the exclusive bit is // set and we don't have the main resource exclusive then // release the current resource and acquire the main resource // exclusively and move to the top of the loop. // if (FlagOn( Header->Flags, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_EX ) || (EndingOffset->QuadPart > Header->ValidDataLength.QuadPart && Header->ValidDataLength.QuadPart != Header->FileSize.QuadPart)) { // // If we don't have the main resource exclusively then // release the current resource and attempt to acquire // the main resource exclusively. // if (!AcquireExclusive) { ExReleaseResource( ResourceAcquired ); AcquireExclusive = TRUE; ResourceAcquired = Header->Resource; continue; } // // We have the correct resource. Exit the loop. // // // If we should be acquiring the main resource shared then move // to acquire the correct resource and proceed to the top of the loop. // } else if (FlagOn( Header->Flags, FSRTL_FLAG_ACQUIRE_MAIN_RSRC_SH )) { // // If we have the main resource exclusively then downgrade to // shared and exit the loop. // if (AcquireExclusive) { ExConvertExclusiveToShared( ResourceAcquired ); // // If we have the paging io resource then give up this resource // and acquire the main resource exclusively. This is going // at it with a large hammer but is guaranteed to be resolved // in the next pass through the loop. // } else if (ResourceAcquired != Header->Resource) { ExReleaseResource( ResourceAcquired ); ResourceAcquired = Header->Resource; AcquireExclusive = TRUE; continue; } // // We have the correct resource. Exit the loop. // // // At this point we should have the paging Io resource shared // if it exists. If not then acquire it shared and release the // other resource and exit the loop. // } else if (Header->PagingIoResource != NULL && ResourceAcquired != Header->PagingIoResource) { ResourceAcquired = NULL; if (ExAcquireSharedWaitForExclusive( Header->PagingIoResource, FALSE )) { ResourceAcquired = Header->PagingIoResource; } ExReleaseResource( Header->Resource ); if (ResourceAcquired == NULL) { return FALSE; } // // We now have the correct resource. Exit the loop. // // // We should have the main resource shared. If we don't then // degrade our lock to shared access. // } else if (AcquireExclusive) { ExConvertExclusiveToShared( ResourceAcquired ); // // We now have the correct resource. Exit the loop. // } // // We have the correct resource. Exit the loop. // break; } *ResourceToRelease = ResourceAcquired; return TRUE; }

BOOLEAN 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 54 of file fastio.c. References ASSERT, Buffer, CcCopyRead(), CcFastCopyRead(), CcFastReadNotPossible, CcFastReadNoWait, CcFastReadResourceMiss, CcFastReadWait, COMPUTE_PAGES_SPANNED, _DEVICE_OBJECT::DriverObject, ExAcquireResourceShared, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, ExReleaseResource, FALSE, _FAST_IO_DISPATCH::FastIoCheckIfPossible, _DRIVER_OBJECT::FastIoDispatch, FastIoIsNotPossible, FastIoIsQuestionable, FO_FILE_FAST_IO_READ, FSRTL_FAST_IO_TOP_LEVEL_IRP, FsRtlEnterFileSystem, FsRtlExitFileSystem, FsRtlIsNtstatusExpected(), Header, HOT_STATISTIC, IoGetRelatedDeviceObject(), NULL, PAGED_CODE, PFAST_IO_DISPATCH, PsGetCurrentThread, Status, TRUE, and VOID(). Referenced by UdfInitializeGlobalData(). : This routine does a fast cached read bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy read of a cached file object. For a complete description of the arguments see CcCopyRead. Arguments: FileObject - Pointer to the file object being read. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. Wait - FALSE if caller may not block, TRUE otherwise Buffer - Pointer to output buffer to which data should be copied. IoStatus - Pointer to standard I/O status block to receive the status for the transfer. Return Value: FALSE - if Wait was supplied as FALSE and the data was not delivered, or if there is an I/O error. TRUE - if the data is being delivered --*/ { PFSRTL_COMMON_FCB_HEADER Header; BOOLEAN Status = TRUE; ULONG PageCount = COMPUTE_PAGES_SPANNED( FileOffset->QuadPart, Length ); LARGE_INTEGER BeyondLastByte; PDEVICE_OBJECT targetVdo; PAGED_CODE(); // // Special case a read of zero length // if (Length != 0) { // // Check for overflow. Returning false here will re-route this request through the // IRP based path, but this isn't performance critical. // if (MAXLONGLONG - FileOffset->QuadPart < (LONGLONG)Length) { IoStatus->Status = STATUS_INVALID_PARAMETER; IoStatus->Information = 0; return FALSE; } BeyondLastByte.QuadPart = FileOffset->QuadPart + (LONGLONG)Length; Header = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext; // // Enter the file system // FsRtlEnterFileSystem(); // // Increment performance counters and get the resource // if (Wait) { HOT_STATISTIC(CcFastReadWait) += 1; // // Acquired shared on the common fcb header // (VOID)ExAcquireResourceShared( Header->Resource, TRUE ); } else { HOT_STATISTIC(CcFastReadNoWait) += 1; // // Acquired shared on the common fcb header, and return if we // don't get it // if (!ExAcquireResourceShared( Header->Resource, FALSE )) { FsRtlExitFileSystem(); CcFastReadResourceMiss += 1; return FALSE; } } // // Now that the File is acquired shared, we can safely test if it // is really cached and if we can do fast i/o and if not, then // release the fcb and return. // if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible)) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); HOT_STATISTIC(CcFastReadNotPossible) += 1; return FALSE; } // // Check if fast I/O is questionable and if so then go ask the // file system the answer // if (Header->IsFastIoPossible == FastIoIsQuestionable) { PFAST_IO_DISPATCH FastIoDispatch; ASSERT(!KeIsExecutingDpc()); targetVdo = IoGetRelatedDeviceObject( FileObject ); FastIoDispatch = targetVdo->DriverObject->FastIoDispatch; // // All file systems that set "Is Questionable" had better support // fast I/O // ASSERT(FastIoDispatch != NULL); ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL); // // Call the file system to check for fast I/O. If the answer is // anything other than GoForIt then we cannot take the fast I/O // path. // if (!FastIoDispatch->FastIoCheckIfPossible( FileObject, FileOffset, Length, Wait, LockKey, TRUE, // read operation IoStatus, targetVdo )) { // // Fast I/O is not possible so release the Fcb and return. // ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); HOT_STATISTIC(CcFastReadNotPossible) += 1; return FALSE; } } // // Check for read past file size. // if ( BeyondLastByte.QuadPart > Header->FileSize.QuadPart ) { if ( FileOffset->QuadPart >= Header->FileSize.QuadPart ) { IoStatus->Status = STATUS_END_OF_FILE; IoStatus->Information = 0; ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return TRUE; } Length = (ULONG)( Header->FileSize.QuadPart - FileOffset->QuadPart ); } // // We can do fast i/o so call the cc routine to do the work and then // release the fcb when we've done. If for whatever reason the // copy read fails, then return FALSE to our caller. // // Also mark this as the top level "Irp" so that lower file system // levels will not attempt a pop-up // PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP; try { if (Wait && ((BeyondLastByte.HighPart | Header->FileSize.HighPart) == 0)) { CcFastCopyRead( FileObject, FileOffset->LowPart, Length, PageCount, Buffer, IoStatus ); FileObject->Flags |= FO_FILE_FAST_IO_READ; ASSERT( (IoStatus->Status == STATUS_END_OF_FILE) || ((FileOffset->LowPart + IoStatus->Information) <= Header->FileSize.LowPart)); } else { Status = CcCopyRead( FileObject, FileOffset, Length, Wait, Buffer, IoStatus ); FileObject->Flags |= FO_FILE_FAST_IO_READ; ASSERT( !Status || (IoStatus->Status == STATUS_END_OF_FILE) || ((LONGLONG)(FileOffset->QuadPart + IoStatus->Information) <= Header->FileSize.QuadPart)); } if (Status) { FileObject->CurrentByteOffset.QuadPart = FileOffset->QuadPart + IoStatus->Information; } } except( FsRtlIsNtstatusExpected(GetExceptionCode()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) { Status = FALSE; } PsGetCurrentThread()->TopLevelIrp = 0; ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return Status; } else { // // A zero length transfer was requested. // IoStatus->Status = STATUS_SUCCESS; IoStatus->Information = 0; return TRUE; } }

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

Definition at line 330 of file fastio.c. References ASSERT, Buffer, CcCanIWrite(), CcCopyWrite(), CcCopyWriteWontFlush, CcFastCopyWrite(), CcGetFileSizePointer, CcZeroData(), _DEVICE_OBJECT::DriverObject, ExAcquireResourceExclusive, ExAcquireResourceShared, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, ExReleaseResource, FALSE, _FAST_IO_DISPATCH::FastIoCheckIfPossible, _DRIVER_OBJECT::FastIoDispatch, FastIoIsNotPossible, FastIoIsQuestionable, FlagOn, FO_FILE_MODIFIED, FO_FILE_SIZE_CHANGED, FO_WRITE_THROUGH, FSRTL_FAST_IO_TOP_LEVEL_IRP, FsRtlEnterFileSystem, FsRtlExitFileSystem, FsRtlIsNtstatusExpected(), Header, IoGetRelatedDeviceObject(), NULL, Offset, PAGED_CODE, PsGetCurrentThread, Status, TRUE, and VOID(). : This routine does a fast cached write bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy write of a cached file object. For a complete description of the arguments see CcCopyWrite. Arguments: FileObject - Pointer to the file object being write. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. Wait - FALSE if caller may not block, TRUE otherwise Buffer - Pointer to output buffer to which data should be copied. IoStatus - Pointer to standard I/O status block to receive the status for the transfer. Return Value: FALSE - if Wait was supplied as FALSE and the data was not delivered, or if there is an I/O error. TRUE - if the data is being delivered --*/ { PFSRTL_COMMON_FCB_HEADER Header; BOOLEAN AcquiredShared = FALSE; BOOLEAN Status = TRUE; BOOLEAN FileSizeChanged = FALSE; BOOLEAN WriteToEndOfFile = (BOOLEAN)((FileOffset->LowPart == FILE_WRITE_TO_END_OF_FILE) && (FileOffset->HighPart == -1)); PAGED_CODE(); // // Get a real pointer to the common fcb header // Header = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext; // // Do we need to verify the volume? If so, we must go to the file // system. Also return FALSE if FileObject is write through, the // File System must do that. // if (CcCanIWrite( FileObject, Length, Wait, FALSE ) && !FlagOn(FileObject->Flags, FO_WRITE_THROUGH) && CcCopyWriteWontFlush(FileObject, FileOffset, Length)) { // // Assume our transfer will work // IoStatus->Status = STATUS_SUCCESS; IoStatus->Information = Length; // // Special case the zero byte length // if (Length != 0) { // // Enter the file system // FsRtlEnterFileSystem(); // // Split into separate paths for increased performance. First // we have the faster path which only supports Wait == TRUE and // 32 bits. We will make an unsafe test on whether the fast path // is ok, then just return FALSE later if we were wrong. This // should virtually never happen. // // IMPORTANT NOTE: It is very important that any changes made to // this path also be applied to the 64-bit path // which is the else of this test! // if (Wait && (Header->AllocationSize.HighPart == 0)) { ULONG Offset, NewFileSize; ULONG OldFileSize; ULONG OldValidDataLength; BOOLEAN Wrapped; // // Make our best guess on whether we need the file exclusive // or shared. Note that we do not check FileOffset->HighPart // until below. // NewFileSize = FileOffset->LowPart + Length; if (WriteToEndOfFile || (NewFileSize > Header->ValidDataLength.LowPart)) { // // Acquired shared on the common fcb header // ExAcquireResourceExclusive( Header->Resource, TRUE ); } else { // // Acquired shared on the common fcb header // ExAcquireResourceShared( Header->Resource, TRUE ); AcquiredShared = TRUE; } // // We have the fcb shared now check if we can do fast i/o // and if the file space is allocated, and if not then // release the fcb and return. // if (WriteToEndOfFile) { Offset = Header->FileSize.LowPart; NewFileSize = Header->FileSize.LowPart + Length; Wrapped = NewFileSize < Header->FileSize.LowPart; } else { Offset = FileOffset->LowPart; NewFileSize = FileOffset->LowPart + Length; Wrapped = (NewFileSize < FileOffset->LowPart) || (FileOffset->HighPart != 0); } // // Now that the File is acquired shared, we can safely test // if it is really cached and if we can do fast i/o and we // do not have to extend. If not then release the fcb and // return. // // Get out if we have too much to zero. This case is not important // for performance, and a file system supporting sparseness may have // a way to do this more efficiently. // if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible) || (NewFileSize > Header->AllocationSize.LowPart) || (Offset >= (Header->ValidDataLength.LowPart + 0x2000)) || (Header->AllocationSize.HighPart != 0) || Wrapped) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } // // If we will be extending ValidDataLength, we will have to // get the Fcb exclusive, and make sure that FastIo is still // possible. We should only execute this block of code very // rarely, when the unsafe test for ValidDataLength failed // above. // if (AcquiredShared && (NewFileSize > Header->ValidDataLength.LowPart)) { ExReleaseResource( Header->Resource ); ExAcquireResourceExclusive( Header->Resource, TRUE ); // // If writing to end of file, we must recalculate new size. // if (WriteToEndOfFile) { Offset = Header->FileSize.LowPart; NewFileSize = Header->FileSize.LowPart + Length; Wrapped = NewFileSize < Header->FileSize.LowPart; } if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible) || (NewFileSize > Header->AllocationSize.LowPart) || (Header->AllocationSize.HighPart != 0) || Wrapped) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } } // // Check if fast I/O is questionable and if so then go ask // the file system the answer // if (Header->IsFastIoPossible == FastIoIsQuestionable) { PDEVICE_OBJECT targetVdo = IoGetRelatedDeviceObject( FileObject ); PFAST_IO_DISPATCH FastIoDispatch = targetVdo->DriverObject->FastIoDispatch; IO_STATUS_BLOCK IoStatus; // // All file system then set "Is Questionable" had better // support fast I/O // ASSERT(FastIoDispatch != NULL); ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL); // // Call the file system to check for fast I/O. If the // answer is anything other than GoForIt then we cannot // take the fast I/O path. // ASSERT(FILE_WRITE_TO_END_OF_FILE == 0xffffffff); if (!FastIoDispatch->FastIoCheckIfPossible( FileObject, FileOffset->QuadPart != (LONGLONG)-1 ? FileOffset : &Header->FileSize, Length, TRUE, LockKey, FALSE, // write operation &IoStatus, targetVdo )) { // // Fast I/O is not possible so release the Fcb and // return. // ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } } // // Now see if we will change FileSize. We have to do it now // so that our reads are not nooped. // if (NewFileSize > Header->FileSize.LowPart) { FileSizeChanged = TRUE; OldFileSize = Header->FileSize.LowPart; OldValidDataLength = Header->ValidDataLength.LowPart; Header->FileSize.LowPart = NewFileSize; } // // We can do fast i/o so call the cc routine to do the work // and then release the fcb when we've done. If for whatever // reason the copy write fails, then return FALSE to our // caller. // // Also mark this as the top level "Irp" so that lower file // system levels will not attempt a pop-up // PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP; try { // // See if we have to do some zeroing // if (Offset > Header->ValidDataLength.LowPart) { LARGE_INTEGER ZeroEnd; ZeroEnd.LowPart = Offset; ZeroEnd.HighPart = 0; CcZeroData( FileObject, &Header->ValidDataLength, &ZeroEnd, TRUE ); } CcFastCopyWrite( FileObject, Offset, Length, Buffer ); } except( FsRtlIsNtstatusExpected(GetExceptionCode()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) { Status = FALSE; } PsGetCurrentThread()->TopLevelIrp = 0; // // If we succeeded, see if we have to update FileSize or // ValidDataLength. // if (Status) { // // In the case of ValidDataLength, we really have to // check again since we did not do this when we acquired // the resource exclusive. // if (NewFileSize > Header->ValidDataLength.LowPart) { Header->ValidDataLength.LowPart = NewFileSize; } // // Set this handle as having modified the file // FileObject->Flags |= FO_FILE_MODIFIED; if (FileSizeChanged) { CcGetFileSizePointer(FileObject)->LowPart = NewFileSize; FileObject->Flags |= FO_FILE_SIZE_CHANGED; } // // Also update the file position pointer // FileObject->CurrentByteOffset.LowPart = Offset + Length; FileObject->CurrentByteOffset.HighPart = 0; // // If we did not succeed, then we must restore the original // FileSize while holding the PagingIoResource exclusive if // it exists. // } else if (FileSizeChanged) { if ( Header->PagingIoResource != NULL ) { (VOID)ExAcquireResourceExclusive( Header->PagingIoResource, TRUE ); Header->FileSize.LowPart = OldFileSize; Header->ValidDataLength.LowPart = OldValidDataLength; ExReleaseResource( Header->PagingIoResource ); } else { Header->FileSize.LowPart = OldFileSize; Header->ValidDataLength.LowPart = OldValidDataLength; } } // // Here is the 64-bit or no-wait path. // } else { LARGE_INTEGER Offset, NewFileSize; LARGE_INTEGER OldFileSize; LARGE_INTEGER OldValidDataLength; ASSERT(!KeIsExecutingDpc()); // // Make our best guess on whether we need the file exclusive // or shared. // NewFileSize.QuadPart = FileOffset->QuadPart + (LONGLONG)Length; if (WriteToEndOfFile || (NewFileSize.QuadPart > Header->ValidDataLength.QuadPart)) { // // Acquired shared on the common fcb header, and return // if we don't get it. // if (!ExAcquireResourceExclusive( Header->Resource, Wait )) { FsRtlExitFileSystem(); return FALSE; } } else { // // Acquired shared on the common fcb header, and return // if we don't get it. // if (!ExAcquireResourceShared( Header->Resource, Wait )) { FsRtlExitFileSystem(); return FALSE; } AcquiredShared = TRUE; } // // We have the fcb shared now check if we can do fast i/o // and if the file space is allocated, and if not then // release the fcb and return. // if (WriteToEndOfFile) { Offset = Header->FileSize; NewFileSize.QuadPart = Header->FileSize.QuadPart + (LONGLONG)Length; } else { Offset = *FileOffset; NewFileSize.QuadPart = FileOffset->QuadPart + (LONGLONG)Length; } // // Now that the File is acquired shared, we can safely test // if it is really cached and if we can do fast i/o and we // do not have to extend. If not then release the fcb and // return. // // Get out if we are about to zero too much as well, as commented above. // Likewise, for NewFileSizes that exceed MAXLONGLONG. // if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible) || (Offset.QuadPart >= (Header->ValidDataLength.QuadPart + 0x2000)) || (MAXLONGLONG - Offset.QuadPart < (LONGLONG)Length) || (NewFileSize.QuadPart > Header->AllocationSize.QuadPart) ) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } // // If we will be extending ValidDataLength, we will have to // get the Fcb exclusive, and make sure that FastIo is still // possible. We should only execute this block of code very // rarely, when the unsafe test for ValidDataLength failed // above. // if (AcquiredShared && ( NewFileSize.QuadPart > Header->ValidDataLength.QuadPart )) { ExReleaseResource( Header->Resource ); if (!ExAcquireResourceExclusive( Header->Resource, Wait )) { FsRtlExitFileSystem(); return FALSE; } // // If writing to end of file, we must recalculate new size. // if (WriteToEndOfFile) { Offset = Header->FileSize; NewFileSize.QuadPart = Header->FileSize.QuadPart + (LONGLONG)Length; } if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible) || ( NewFileSize.QuadPart > Header->AllocationSize.QuadPart ) ) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } } // // Check if fast I/O is questionable and if so then go ask // the file system the answer // if (Header->IsFastIoPossible == FastIoIsQuestionable) { PFAST_IO_DISPATCH FastIoDispatch = IoGetRelatedDeviceObject( FileObject )->DriverObject->FastIoDispatch; IO_STATUS_BLOCK IoStatus; // // All file system then set "Is Questionable" had better // support fast I/O // ASSERT(FastIoDispatch != NULL); ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL); // // Call the file system to check for fast I/O. If the // answer is anything other than GoForIt then we cannot // take the fast I/O path. // ASSERT(FILE_WRITE_TO_END_OF_FILE == 0xffffffff); if (!FastIoDispatch->FastIoCheckIfPossible( FileObject, FileOffset->QuadPart != (LONGLONG)-1 ? FileOffset : &Header->FileSize, Length, Wait, LockKey, FALSE, // write operation &IoStatus, DeviceObject )) { // // Fast I/O is not possible so release the Fcb and // return. // ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } } // // Now see if we will change FileSize. We have to do it now // so that our reads are not nooped. // if ( NewFileSize.QuadPart > Header->FileSize.QuadPart ) { FileSizeChanged = TRUE; OldFileSize = Header->FileSize; OldValidDataLength = Header->ValidDataLength; // // Deal with an extremely rare pathalogical case here the // file size wraps. // if ( (Header->FileSize.HighPart != NewFileSize.HighPart) && (Header->PagingIoResource != NULL) ) { (VOID)ExAcquireResourceExclusive( Header->PagingIoResource, TRUE ); Header->FileSize = NewFileSize; ExReleaseResource( Header->PagingIoResource ); } else { Header->FileSize = NewFileSize; } } // // We can do fast i/o so call the cc routine to do the work // and then release the fcb when we've done. If for whatever // reason the copy write fails, then return FALSE to our // caller. // // Also mark this as the top level "Irp" so that lower file // system levels will not attempt a pop-up // PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP; try { // // See if we have to do some zeroing // if ( Offset.QuadPart > Header->ValidDataLength.QuadPart ) { Status = CcZeroData( FileObject, &Header->ValidDataLength, &Offset, Wait ); } if (Status) { Status = CcCopyWrite( FileObject, &Offset, Length, Wait, Buffer ); } } except( FsRtlIsNtstatusExpected(GetExceptionCode()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) { Status = FALSE; } PsGetCurrentThread()->TopLevelIrp = 0; // // If we succeeded, see if we have to update FileSize or // ValidDataLength. // if (Status) { // // In the case of ValidDataLength, we really have to // check again since we did not do this when we acquired // the resource exclusive. // if ( NewFileSize.QuadPart > Header->ValidDataLength.QuadPart ) { // // Deal with an extremely rare pathalogical case here // the ValidDataLength wraps. // if ( (Header->ValidDataLength.HighPart != NewFileSize.HighPart) && (Header->PagingIoResource != NULL) ) { (VOID)ExAcquireResourceExclusive( Header->PagingIoResource, TRUE ); Header->ValidDataLength = NewFileSize; ExReleaseResource( Header->PagingIoResource ); } else { Header->ValidDataLength = NewFileSize; } } // // Set this handle as having modified the file // FileObject->Flags |= FO_FILE_MODIFIED; if (FileSizeChanged) { *CcGetFileSizePointer(FileObject) = NewFileSize; FileObject->Flags |= FO_FILE_SIZE_CHANGED; } // // Also update the current file position pointer // FileObject->CurrentByteOffset.QuadPart = Offset.QuadPart + Length; // // If we did not succeed, then we must restore the original // FileSize while holding the PagingIoResource exclusive if // it exists. // } else if (FileSizeChanged) { if ( Header->PagingIoResource != NULL ) { (VOID)ExAcquireResourceExclusive( Header->PagingIoResource, TRUE ); Header->FileSize = OldFileSize; Header->ValidDataLength = OldValidDataLength; ExReleaseResource( Header->PagingIoResource ); } else { Header->FileSize = OldFileSize; Header->ValidDataLength = OldValidDataLength; } } } ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return Status; } else { // // A zero length transfer was requested. // return TRUE; } } else { // // The volume must be verified or the file is write through. // return FALSE; } }

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

Definition at line 2691 of file fastio.c. References _IRP::AssociatedIrp, _IO_STACK_LOCATION::DeviceObject, _DEVICE_OBJECT::DriverObject, Event(), Executive, FALSE, _DRIVER_OBJECT::FastIoDispatch, _FAST_IO_DISPATCH::FastIoQueryStandardInfo, _IO_STACK_LOCATION::FileObject, _IRP::Flags, IoAllocateIrp(), IoCallDriver, IoGetNextIrpStackLocation, IoGetRelatedDeviceObject(), Irp, IRP_MJ_QUERY_INFORMATION, IRP_PAGING_IO, IRP_SYNCHRONOUS_PAGING_IO, KeInitializeEvent, KernelMode, KeWaitForSingleObject(), _IO_STACK_LOCATION::MajorFunction, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, _IO_STACK_LOCATION::Parameters, PsGetCurrentThread, _IRP::RequestorMode, _DEVICE_OBJECT::StackSize, Status, _IRP::Tail, TRUE, _IRP::UserEvent, and _IRP::UserIosb. Referenced by MiCreateDataFileMap(), MiCreateImageFileMap(), MmCreateSection(), and MmExtendSection(). 02698 : 02699 02700 This routine is used to call the File System to get the FileSize 02701 for a file. 02702 02703 It does this without acquiring the file object lock on synchronous file 02704 objects. This routine is therefore safe to call if you already own 02705 file system resources, while IoQueryFileInformation could (and does) 02706 lead to deadlocks. 02707 02708 Arguments: 02709 02710 FileObject - The file to query 02711 FileSize - Receives the file size. 02712 02713 Return Value: 02714 02715 NTSTATUS - The final I/O status of the operation. If the FileObject 02716 refers to a directory, STATUS_FILE_IS_A_DIRECTORY is returned. 02717 02718 --*/ 02719 { 02720 IO_STATUS_BLOCK IoStatus; 02721 PDEVICE_OBJECT DeviceObject; 02722 PFAST_IO_DISPATCH FastIoDispatch; 02723 FILE_STANDARD_INFORMATION FileInformation; 02724 02725 PAGED_CODE(); 02726 02727 // 02728 // Get the address of the target device object. 02729 // 02730 02731 DeviceObject = IoGetRelatedDeviceObject( FileObject ); 02732 02733 // 02734 // Try the fast query call if it exists. 02735 // 02736 02737 FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; 02738 02739 if (FastIoDispatch && 02740 FastIoDispatch->FastIoQueryStandardInfo && 02741 FastIoDispatch->FastIoQueryStandardInfo( FileObject, 02742 TRUE, 02743 &FileInformation, 02744 &IoStatus, 02745 DeviceObject )) { 02746 // 02747 // Cool, it worked. 02748 // 02749 02750 } else { 02751 02752 // 02753 // Life's tough, take the long path. 02754 // 02755 02756 PIRP Irp; 02757 KEVENT Event; 02758 NTSTATUS Status; 02759 PIO_STACK_LOCATION IrpSp; 02760 02761 // 02762 // Initialize the event. 02763 // 02764 02765 KeInitializeEvent( &Event, NotificationEvent, FALSE ); 02766 02767 // 02768 // Allocate an I/O Request Packet (IRP) for this in-page operation. 02769 // 02770 02771 Irp = IoAllocateIrp( DeviceObject->StackSize, FALSE ); 02772 if (Irp == NULL) { 02773 02774 return STATUS_INSUFFICIENT_RESOURCES; 02775 } 02776 02777 // 02778 // Get a pointer to the first stack location in the packet. This location 02779 // will be used to pass the function codes and parameters to the first 02780 // driver. 02781 // 02782 02783 IrpSp = IoGetNextIrpStackLocation( Irp ); 02784 02785 // 02786 // Fill in the IRP according to this request, setting the flags to 02787 // just cause IO to set the event and deallocate the Irp. 02788 // 02789 02790 Irp->Flags = IRP_PAGING_IO | IRP_SYNCHRONOUS_PAGING_IO; 02791 Irp->RequestorMode = KernelMode; 02792 Irp->UserIosb = &IoStatus; 02793 Irp->UserEvent = &Event; 02794 Irp->Tail.Overlay.OriginalFileObject = FileObject; 02795 Irp->Tail.Overlay.Thread = PsGetCurrentThread(); 02796 Irp->AssociatedIrp.SystemBuffer = &FileInformation; 02797 02798 // 02799 // Fill in the normal query parameters. 02800 // 02801 02802 IrpSp->MajorFunction = IRP_MJ_QUERY_INFORMATION; 02803 IrpSp->FileObject = FileObject; 02804 IrpSp->DeviceObject = DeviceObject; 02805 IrpSp->Parameters.SetFile.Length = sizeof(FILE_STANDARD_INFORMATION); 02806 IrpSp->Parameters.SetFile.FileInformationClass = FileStandardInformation; 02807 02808 // 02809 // Queue the packet to the appropriate driver based. This routine 02810 // should not raise. 02811 // 02812 02813 Status = IoCallDriver( DeviceObject, Irp ); 02814 02815 // 02816 // If pending is returned (which is a successful status), 02817 // we must wait for the request to complete. 02818 // 02819 02820 if (Status == STATUS_PENDING) { 02821 KeWaitForSingleObject( &Event, 02822 Executive, 02823 KernelMode, 02824 FALSE, 02825 (PLARGE_INTEGER)NULL); 02826 } 02827 02828 // 02829 // If we got an error back in Status, then the Iosb 02830 // was not written, so we will just copy the status 02831 // there, then test the final status after that. 02832 // 02833 02834 if (!NT_SUCCESS(Status)) { 02835 IoStatus.Status = Status; 02836 } 02837 } 02838 02839 // 02840 // If the call worked, check to make sure it wasn't a directory and 02841 // if not, fill in the FileSize parameter. 02842 // 02843 02844 if (NT_SUCCESS(IoStatus.Status)) { 02845 02846 if (FileInformation.Directory) { 02847 02848 // 02849 // Can't get file size for a directory. Return error. 02850 // 02851 02852 IoStatus.Status = STATUS_FILE_IS_A_DIRECTORY; 02853 02854 } else { 02855 02856 *FileSize = FileInformation.EndOfFile; 02857 } 02858 } 02859 02860 return IoStatus.Status; 02861 }

BOOLEAN 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 1277 of file fastio.c. References _DEVICE_OBJECT::DriverObject, FALSE, FAST_IO_DISPATCH, _DRIVER_OBJECT::FastIoDispatch, FsRtlMdlReadDev(), IoGetBaseFileSystemDeviceObject(), IoGetRelatedDeviceObject(), _FAST_IO_DISPATCH::MdlRead, NULL, and _FAST_IO_DISPATCH::SizeOfFastIoDispatch. : This routine does a fast cached mdl read bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy read of a cached file object. For a complete description of the arguments see CcMdlRead. Arguments: FileObject - Pointer to the file object being read. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. MdlChain - On output it returns a pointer to an MDL chain describing the desired data. IoStatus - Pointer to standard I/O status block to receive the status for the transfer. Return Value: FALSE - if the data was not delivered, or if there is an I/O error. TRUE - if the data is being delivered --*/ { PDEVICE_OBJECT DeviceObject, VolumeDeviceObject; PFAST_IO_DISPATCH FastIoDispatch; DeviceObject = IoGetRelatedDeviceObject( FileObject ); FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; // // See if the (top-level) FileSystem has a FastIo routine, and if so, call it. // if ((FastIoDispatch != NULL) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlRead)) && (FastIoDispatch->MdlRead != NULL)) { return FastIoDispatch->MdlRead( FileObject, FileOffset, Length, LockKey, MdlChain, IoStatus, DeviceObject ); } else { // // Get the DeviceObject for the volume. If that DeviceObject is different, and // it specifies the FastIo routine, then we have to return FALSE here and cause // an Irp to get generated. // VolumeDeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); if ((VolumeDeviceObject != DeviceObject) && (FastIoDispatch = VolumeDeviceObject->DriverObject->FastIoDispatch) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlRead)) && (FastIoDispatch->MdlRead != NULL)) { return FALSE; // // Otherwise, call the default routine. // } else { return FsRtlMdlReadDev( FileObject, FileOffset, Length, LockKey, MdlChain, IoStatus, DeviceObject ); } } }

BOOLEAN FsRtlMdlReadComplete (  IN PFILE_OBJECT  FileObject, IN PMDL  MdlChain )

Definition at line 1367 of file fastio.c. References _DEVICE_OBJECT::DriverObject, FALSE, _DRIVER_OBJECT::FastIoDispatch, FsRtlMdlReadCompleteDev(), IoGetBaseFileSystemDeviceObject(), IoGetRelatedDeviceObject(), _FAST_IO_DISPATCH::MdlReadComplete, NULL, and _FAST_IO_DISPATCH::SizeOfFastIoDispatch. : This routine does a fast cached mdl read bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy read of a cached file object. Arguments: FileObject - Pointer to the file object being read. MdlChain - Supplies a pointer to an MDL chain returned from CcMdlRead. Return Value: None --*/ { PDEVICE_OBJECT DeviceObject, VolumeDeviceObject; PFAST_IO_DISPATCH FastIoDispatch; DeviceObject = IoGetRelatedDeviceObject( FileObject ); FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; // // See if the (top-level) FileSystem has a FastIo routine, and if so, call it. // if ((FastIoDispatch != NULL) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlReadComplete)) && (FastIoDispatch->MdlReadComplete != NULL)) { return FastIoDispatch->MdlReadComplete( FileObject, MdlChain, DeviceObject ); } else { // // Get the DeviceObject for the volume. If that DeviceObject is different, and // it specifies the FastIo routine, then we have to return FALSE here and cause // an Irp to get generated. // VolumeDeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); if ((VolumeDeviceObject != DeviceObject) && (FastIoDispatch = VolumeDeviceObject->DriverObject->FastIoDispatch) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlReadComplete)) && (FastIoDispatch->MdlReadComplete != NULL)) { return FALSE; // // Otherwise, call the default routine. // } else { return FsRtlMdlReadCompleteDev( FileObject, MdlChain, DeviceObject ); } } }

BOOLEAN FsRtlMdlReadCompleteDev (  IN PFILE_OBJECT  FileObject, IN PMDL  MdlChain, IN PDEVICE_OBJECT  DeviceObject )

Definition at line 1438 of file fastio.c. References CcMdlReadComplete2(), and TRUE. Referenced by FsRtlMdlReadComplete(). : This routine does a fast cached mdl read bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy read of a cached file object. Arguments: FileObject - Pointer to the file object being read. MdlChain - Supplies a pointer to an MDL chain returned from CcMdlRead. DeviceObject - Supplies the DeviceObject for the callee. Return Value: None --*/ { CcMdlReadComplete2( FileObject, MdlChain ); return TRUE; }

BOOLEAN 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 1064 of file fastio.c. References ASSERT, CcFastMdlReadNotPossible, CcFastMdlReadWait, CcMdlRead(), _DEVICE_OBJECT::DriverObject, ExAcquireResourceShared, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, ExReleaseResource, FALSE, _FAST_IO_DISPATCH::FastIoCheckIfPossible, _DRIVER_OBJECT::FastIoDispatch, FastIoIsNotPossible, FastIoIsQuestionable, FO_FILE_FAST_IO_READ, FSRTL_FAST_IO_TOP_LEVEL_IRP, FsRtlEnterFileSystem, FsRtlExitFileSystem, FsRtlIsNtstatusExpected(), Header, IoGetRelatedDeviceObject(), NULL, PAGED_CODE, PsGetCurrentThread, Status, TRUE, and VOID(). Referenced by FsRtlMdlRead(). : This routine does a fast cached mdl read bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy read of a cached file object. For a complete description of the arguments see CcMdlRead. Arguments: FileObject - Pointer to the file object being read. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. MdlChain - On output it returns a pointer to an MDL chain describing the desired data. IoStatus - Pointer to standard I/O status block to receive the status for the transfer. DeviceObject - Supplies DeviceObject for callee. Return Value: FALSE - if the data was not delivered, or if there is an I/O error. TRUE - if the data is being delivered --*/ { PFSRTL_COMMON_FCB_HEADER Header; BOOLEAN Status = TRUE; LARGE_INTEGER BeyondLastByte; PAGED_CODE(); // // Special case a read of zero length // if (Length == 0) { IoStatus->Status = STATUS_SUCCESS; IoStatus->Information = 0; return TRUE; } // // Overflows should've been handled by caller. // ASSERT(MAXLONGLONG - FileOffset->QuadPart >= (LONGLONG)Length); // // Get a real pointer to the common fcb header // BeyondLastByte.QuadPart = FileOffset->QuadPart + (LONGLONG)Length; Header = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext; // // Enter the file system // FsRtlEnterFileSystem(); CcFastMdlReadWait += 1; // // Acquired shared on the common fcb header // (VOID)ExAcquireResourceShared( Header->Resource, TRUE ); // // Now that the File is acquired shared, we can safely test if it is // really cached and if we can do fast i/o and if not // then release the fcb and return. // if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible)) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); CcFastMdlReadNotPossible += 1; return FALSE; } // // Check if fast I/O is questionable and if so then go ask the file system // the answer // if (Header->IsFastIoPossible == FastIoIsQuestionable) { PFAST_IO_DISPATCH FastIoDispatch; ASSERT(!KeIsExecutingDpc()); FastIoDispatch = IoGetRelatedDeviceObject( FileObject )->DriverObject->FastIoDispatch; // // All file system then set "Is Questionable" had better support fast I/O // ASSERT(FastIoDispatch != NULL); ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL); // // Call the file system to check for fast I/O. If the answer is anything // other than GoForIt then we cannot take the fast I/O path. // if (!FastIoDispatch->FastIoCheckIfPossible( FileObject, FileOffset, Length, TRUE, LockKey, TRUE, // read operation IoStatus, IoGetRelatedDeviceObject( FileObject ) )) { // // Fast I/O is not possible so release the Fcb and return. // ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); CcFastMdlReadNotPossible += 1; return FALSE; } } // // Check for read past file size. // if ( BeyondLastByte.QuadPart > Header->FileSize.QuadPart ) { if ( FileOffset->QuadPart >= Header->FileSize.QuadPart ) { IoStatus->Status = STATUS_END_OF_FILE; IoStatus->Information = 0; ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return TRUE; } Length = (ULONG)( Header->FileSize.QuadPart - FileOffset->QuadPart ); } // // We can do fast i/o so call the cc routine to do the work and then // release the fcb when we've done. If for whatever reason the // mdl read fails, then return FALSE to our caller. // // // Also mark this as the top level "Irp" so that lower file system levels // will not attempt a pop-up // PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP; try { CcMdlRead( FileObject, FileOffset, Length, MdlChain, IoStatus ); FileObject->Flags |= FO_FILE_FAST_IO_READ; } except( FsRtlIsNtstatusExpected(GetExceptionCode()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) { Status = FALSE; } PsGetCurrentThread()->TopLevelIrp = 0; ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return Status; }

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

Definition at line 1950 of file fastio.c. References _DEVICE_OBJECT::DriverObject, FALSE, _DRIVER_OBJECT::FastIoDispatch, FsRtlMdlWriteCompleteDev(), IoGetBaseFileSystemDeviceObject(), IoGetRelatedDeviceObject(), _FAST_IO_DISPATCH::MdlWriteComplete, NULL, and _FAST_IO_DISPATCH::SizeOfFastIoDispatch. : This routine completes an Mdl write. Arguments: FileObject - Pointer to the file object being read. MdlChain - Supplies a pointer to an MDL chain returned from CcMdlPrepareMdlWrite. Return Value: --*/ { PDEVICE_OBJECT DeviceObject, VolumeDeviceObject; PFAST_IO_DISPATCH FastIoDispatch; DeviceObject = IoGetRelatedDeviceObject( FileObject ); FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; // // See if the (top-level) FileSystem has a FastIo routine, and if so, call it. // if ((FastIoDispatch != NULL) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlWriteComplete)) && (FastIoDispatch->MdlWriteComplete != NULL)) { return FastIoDispatch->MdlWriteComplete( FileObject, FileOffset, MdlChain, DeviceObject ); } else { // // Get the DeviceObject for the volume. If that DeviceObject is different, and // it specifies the FastIo routine, then we have to return FALSE here and cause // an Irp to get generated. // VolumeDeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); if ((VolumeDeviceObject != DeviceObject) && (FastIoDispatch = VolumeDeviceObject->DriverObject->FastIoDispatch) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, MdlWriteComplete)) && (FastIoDispatch->MdlWriteComplete != NULL)) { return FALSE; // // Otherwise, call the default routine. // } else { return FsRtlMdlWriteCompleteDev( FileObject, FileOffset, MdlChain, DeviceObject ); } } }

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

Definition at line 2020 of file fastio.c. References CcMdlWriteComplete2(), FALSE, FlagOn, FO_WRITE_THROUGH, and TRUE. Referenced by FsRtlMdlWriteComplete(). : This routine completes an Mdl write. Arguments: FileObject - Pointer to the file object being read. MdlChain - Supplies a pointer to an MDL chain returned from CcMdlPrepareMdlWrite. DeviceObject - Supplies the DeviceObject for the callee. Return Value: --*/ { // // Do not support WRITE_THROUGH in the fast path call. // if (FlagOn( FileObject->Flags, FO_WRITE_THROUGH )) { return FALSE; } CcMdlWriteComplete2( FileObject, FileOffset, MdlChain ); return TRUE; }

BOOLEAN 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 1860 of file fastio.c. References _DEVICE_OBJECT::DriverObject, FALSE, _DRIVER_OBJECT::FastIoDispatch, FsRtlPrepareMdlWriteDev(), IoGetBaseFileSystemDeviceObject(), IoGetRelatedDeviceObject(), NULL, _FAST_IO_DISPATCH::PrepareMdlWrite, and _FAST_IO_DISPATCH::SizeOfFastIoDispatch. : This routine does a fast cached mdl read bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy read of a cached file object. For a complete description of the arguments see CcMdlRead. Arguments: FileObject - Pointer to the file object being read. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. MdlChain - On output it returns a pointer to an MDL chain describing the desired data. IoStatus - Pointer to standard I/O status block to receive the status for the transfer. Return Value: FALSE - if the data was not written, or if there is an I/O error. TRUE - if the data is being written --*/ { PDEVICE_OBJECT DeviceObject, VolumeDeviceObject; PFAST_IO_DISPATCH FastIoDispatch; DeviceObject = IoGetRelatedDeviceObject( FileObject ); FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; // // See if the (top-level) FileSystem has a FastIo routine, and if so, call it. // if ((FastIoDispatch != NULL) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, PrepareMdlWrite)) && (FastIoDispatch->PrepareMdlWrite != NULL)) { return FastIoDispatch->PrepareMdlWrite( FileObject, FileOffset, Length, LockKey, MdlChain, IoStatus, DeviceObject ); } else { // // Get the DeviceObject for the volume. If that DeviceObject is different, and // it specifies the FastIo routine, then we have to return FALSE here and cause // an Irp to get generated. // VolumeDeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); if ((VolumeDeviceObject != DeviceObject) && (FastIoDispatch = VolumeDeviceObject->DriverObject->FastIoDispatch) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET(FAST_IO_DISPATCH, PrepareMdlWrite)) && (FastIoDispatch->PrepareMdlWrite != NULL)) { return FALSE; // // Otherwise, call the default routine. // } else { return FsRtlPrepareMdlWriteDev( FileObject, FileOffset, Length, LockKey, MdlChain, IoStatus, DeviceObject ); } } }

BOOLEAN 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 1474 of file fastio.c. References ASSERT, CcCanIWrite(), CcGetFileSizePointer, CcPrepareMdlWrite(), CcZeroData(), _DEVICE_OBJECT::DriverObject, ExAcquireResourceExclusive, ExAcquireResourceShared, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, ExReleaseResource, FALSE, _FAST_IO_DISPATCH::FastIoCheckIfPossible, _DRIVER_OBJECT::FastIoDispatch, FastIoIsNotPossible, FastIoIsQuestionable, FlagOn, FO_FILE_MODIFIED, FO_FILE_SIZE_CHANGED, FO_WRITE_THROUGH, FSRTL_FAST_IO_TOP_LEVEL_IRP, FsRtlEnterFileSystem, FsRtlExitFileSystem, FsRtlIsNtstatusExpected(), Header, IoGetRelatedDeviceObject(), NULL, Offset, PAGED_CODE, PsGetCurrentThread, Status, TRUE, and VOID(). Referenced by FsRtlPrepareMdlWrite(). : This routine does a fast cached mdl read bypassing the usual file system entry routine (i.e., without the Irp). It is used to do a copy read of a cached file object. For a complete description of the arguments see CcMdlRead. Arguments: FileObject - Pointer to the file object being read. FileOffset - Byte offset in file for desired data. Length - Length of desired data in bytes. MdlChain - On output it returns a pointer to an MDL chain describing the desired data. IoStatus - Pointer to standard I/O status block to receive the status for the transfer. DeviceObject - Supplies the DeviceObject for the callee. Return Value: FALSE - if the data was not written, or if there is an I/O error. TRUE - if the data is being written --*/ { PFSRTL_COMMON_FCB_HEADER Header; LARGE_INTEGER Offset, NewFileSize; LARGE_INTEGER OldFileSize; LARGE_INTEGER OldValidDataLength; BOOLEAN Status = TRUE; BOOLEAN AcquiredShared = FALSE; BOOLEAN FileSizeChanged = FALSE; BOOLEAN WriteToEndOfFile = (BOOLEAN)((FileOffset->LowPart == FILE_WRITE_TO_END_OF_FILE) && (FileOffset->HighPart == -1)); PAGED_CODE(); // // Call CcCanIWrite. Also return FALSE if FileObject is write through, // the File System must do that. // if ( !CcCanIWrite( FileObject, Length, TRUE, FALSE ) || FlagOn( FileObject->Flags, FO_WRITE_THROUGH )) { return FALSE; } // // Assume our transfer will work // IoStatus->Status = STATUS_SUCCESS; // // Special case the zero byte length // if (Length == 0) { return TRUE; } // // Get a real pointer to the common fcb header // Header = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext; // // Enter the file system // FsRtlEnterFileSystem(); // // Make our best guess on whether we need the file exclusive or // shared. // NewFileSize.QuadPart = FileOffset->QuadPart + (LONGLONG)Length; if (WriteToEndOfFile || (NewFileSize.QuadPart > Header->ValidDataLength.QuadPart)) { // // Acquired exclusive on the common fcb header, and return if we don't // get it. // ExAcquireResourceExclusive( Header->Resource, TRUE ); } else { // // Acquired shared on the common fcb header, and return if we don't // get it. // ExAcquireResourceShared( Header->Resource, TRUE ); AcquiredShared = TRUE; } // // We have the fcb shared now check if we can do fast i/o and if the file // space is allocated, and if not then release the fcb and return. // if (WriteToEndOfFile) { Offset = Header->FileSize; NewFileSize.QuadPart = Header->FileSize.QuadPart + (LONGLONG)Length; } else { Offset = *FileOffset; NewFileSize.QuadPart = FileOffset->QuadPart + (LONGLONG)Length; } // // Now that the File is acquired shared, we can safely test if it is // really cached and if we can do fast i/o and we do not have to extend. // If not then release the fcb and return. // if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible) || (MAXLONGLONG - Offset.QuadPart < (LONGLONG)Length) || ( NewFileSize.QuadPart > Header->AllocationSize.QuadPart ) ) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } // // If we will be extending ValidDataLength, we will have to get the // Fcb exclusive, and make sure that FastIo is still possible. // if (AcquiredShared && ( NewFileSize.QuadPart > Header->ValidDataLength.QuadPart )) { ExReleaseResource( Header->Resource ); ExAcquireResourceExclusive( Header->Resource, TRUE ); AcquiredShared = FALSE; // // If writing to end of file, we must recalculate new size. // if (WriteToEndOfFile) { Offset = Header->FileSize; NewFileSize.QuadPart = Header->FileSize.QuadPart + (LONGLONG)Length; } if ((FileObject->PrivateCacheMap == NULL) || (Header->IsFastIoPossible == FastIoIsNotPossible) || ( NewFileSize.QuadPart > Header->AllocationSize.QuadPart )) { ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } } // // Check if fast I/O is questionable and if so then go ask the file system // the answer // if (Header->IsFastIoPossible == FastIoIsQuestionable) { PFAST_IO_DISPATCH FastIoDispatch = IoGetRelatedDeviceObject( FileObject )->DriverObject->FastIoDispatch; // // All file system then set "Is Questionable" had better support fast I/O // ASSERT(FastIoDispatch != NULL); ASSERT(FastIoDispatch->FastIoCheckIfPossible != NULL); // // Call the file system to check for fast I/O. If the answer is anything // other than GoForIt then we cannot take the fast I/O path. // if (!FastIoDispatch->FastIoCheckIfPossible( FileObject, FileOffset, Length, TRUE, LockKey, FALSE, // write operation IoStatus, IoGetRelatedDeviceObject( FileObject ) )) { // // Fast I/O is not possible so release the Fcb and return. // ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return FALSE; } } // // Now see if we will change FileSize. We have to do it now so that our // reads are not nooped. // if ( NewFileSize.QuadPart > Header->FileSize.QuadPart ) { FileSizeChanged = TRUE; OldFileSize = Header->FileSize; OldValidDataLength = Header->ValidDataLength; // // Deal with an extremely rare pathalogical case here the file // size wraps. // if ( (Header->FileSize.HighPart != NewFileSize.HighPart) && (Header->PagingIoResource != NULL) ) { (VOID)ExAcquireResourceExclusive( Header->PagingIoResource, TRUE ); Header->FileSize = NewFileSize; ExReleaseResource( Header->PagingIoResource ); } else { Header->FileSize = NewFileSize; } } // // We can do fast i/o so call the cc routine to do the work and then // release the fcb when we've done. If for whatever reason the // copy write fails, then return FALSE to our caller. // // // Also mark this as the top level "Irp" so that lower file system levels // will not attempt a pop-up // PsGetCurrentThread()->TopLevelIrp = FSRTL_FAST_IO_TOP_LEVEL_IRP; try { // // See if we have to do some zeroing // if ( Offset.QuadPart > Header->ValidDataLength.QuadPart ) { Status = CcZeroData( FileObject, &Header->ValidDataLength, &Offset, TRUE ); } if (Status) { CcPrepareMdlWrite( FileObject, &Offset, Length, MdlChain, IoStatus ); } } except( FsRtlIsNtstatusExpected(GetExceptionCode()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) { Status = FALSE; } PsGetCurrentThread()->TopLevelIrp = 0; // // If we succeeded, see if we have to update FileSize or ValidDataLength. // if (Status) { // // In the case of ValidDataLength, we really have to check again // since we did not do this when we acquired the resource exclusive. // if ( NewFileSize.QuadPart > Header->ValidDataLength.QuadPart ) { // // Deal with an extremely rare pathalogical case here the // ValidDataLength wraps. // if ( (Header->ValidDataLength.HighPart != NewFileSize.HighPart) && (Header->PagingIoResource != NULL) ) { (VOID)ExAcquireResourceExclusive( Header->PagingIoResource, TRUE ); Header->ValidDataLength = NewFileSize; ExReleaseResource( Header->PagingIoResource ); } else { Header->ValidDataLength = NewFileSize; } } // // Set this handle as having modified the file // FileObject->Flags |= FO_FILE_MODIFIED; if (FileSizeChanged) { *CcGetFileSizePointer(FileObject) = NewFileSize; FileObject->Flags |= FO_FILE_SIZE_CHANGED; } // // If we did not succeed, then we must restore the original FileSize // and release the resource. In the success path, the cache manager // will release the resource. // } else { if (FileSizeChanged) { if ( Header->PagingIoResource != NULL ) { (VOID)ExAcquireResourceExclusive( Header->PagingIoResource, TRUE ); Header->FileSize = OldFileSize; Header->ValidDataLength = OldValidDataLength; ExReleaseResource( Header->PagingIoResource ); } else { Header->FileSize = OldFileSize; Header->ValidDataLength = OldValidDataLength; } } } // // Now we can release the resource. // ExReleaseResource( Header->Resource ); FsRtlExitFileSystem(); return Status; }

NTKERNELAPI VOID FsRtlReleaseFile (  IN PFILE_OBJECT  FileObject  )

Definition at line 2628 of file fastio.c. References _DEVICE_OBJECT::DriverObject, ExReleaseResource, _DRIVER_OBJECT::FastIoDispatch, FsRtlExitFileSystem, Header, IoGetBaseFileSystemDeviceObject(), NULL, PAGED_CODE, _FAST_IO_DISPATCH::ReleaseFileForNtCreateSection, and _FAST_IO_DISPATCH::SizeOfFastIoDispatch. Referenced by CcDeleteSharedCacheMap(), CcWriteBehind(), CcZeroEndOfLastPage(), and MmCreateSection(). 02634 : 02635 02636 This routine releases resources acquired by FsRtlAcquireFileExclusive. 02637 02638 Arguments: 02639 02640 FileObject - Pointer to the file object being written. 02641 02642 Return Value: 02643 02644 None. 02645 02646 --*/ 02647 02648 { 02649 PDEVICE_OBJECT DeviceObject; 02650 PFAST_IO_DISPATCH FastIoDispatch; 02651 PFSRTL_COMMON_FCB_HEADER Header; 02652 02653 PAGED_CODE(); 02654 02655 // 02656 // First see if we have to call the file system. 02657 // 02658 02659 DeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); 02660 02661 if ((FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch) && 02662 (FastIoDispatch->SizeOfFastIoDispatch > 02663 FIELD_OFFSET( FAST_IO_DISPATCH, ReleaseFileForNtCreateSection )) && 02664 (FastIoDispatch->ReleaseFileForNtCreateSection != NULL)) { 02665 02666 FastIoDispatch->ReleaseFileForNtCreateSection( FileObject ); 02667 FsRtlExitFileSystem(); 02668 return; 02669 } 02670 02671 // 02672 // If there is a main file resource, release that. 02673 // 02674 02675 if ((Header = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext) && 02676 (Header->Resource != NULL)) { 02677 02678 ExReleaseResource( Header->Resource ); 02679 FsRtlExitFileSystem(); 02680 return; 02681 } 02682 02683 // 02684 // Nothing to release. 02685 // 02686 02687 return; 02688 }

NTKERNELAPI VOID FsRtlReleaseFileForCcFlush (  IN PFILE_OBJECT  FileObject  )

Definition at line 2483 of file fastio.c. References ASSERT, _DEVICE_OBJECT::DriverObject, ExReleaseResource, _DRIVER_OBJECT::FastIoDispatch, FsRtlExitFileSystem, Header, IoGetBaseFileSystemDeviceObject(), NTSTATUS(), NULL, PAGED_CODE, _FAST_IO_DISPATCH::ReleaseForCcFlush, _FAST_IO_DISPATCH::SizeOfFastIoDispatch, and Status. Referenced by MiRemoveUnusedSegments(), MmFlushSection(), and MmFlushVirtualMemory(). : This routine releases a file system resource previously acquired for the CcFlush. Arguments: FileObject - Pointer to the file object being written. Return Value: None. --*/ { PDEVICE_OBJECT DeviceObject; PFAST_IO_DISPATCH FastIoDispatch; NTSTATUS Status = STATUS_INVALID_DEVICE_REQUEST; PAGED_CODE(); // // First see if we have to call the file system. Note that in the case // of layered file systems, the layered file system might have the // dispatch routine, but the file system on which it is layered on may // not. In that case, the layered file system will return // STATUS_INVALID_DEVICE_REQUEST. // DeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); if ((FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch) && (FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET( FAST_IO_DISPATCH, ReleaseForCcFlush )) && (FastIoDispatch->ReleaseForCcFlush != NULL)) { Status = FastIoDispatch->ReleaseForCcFlush( FileObject, DeviceObject ); } ASSERT( (Status == STATUS_SUCCESS) || (Status == STATUS_INVALID_DEVICE_REQUEST) ); if (Status == STATUS_INVALID_DEVICE_REQUEST) { PFSRTL_COMMON_FCB_HEADER Header = FileObject->FsContext; // // Free whatever we acquired. // if (Header->PagingIoResource != NULL) { ExReleaseResource( Header->PagingIoResource ); } if (Header->Resource != NULL) { ExReleaseResource( Header->Resource ); } } FsRtlExitFileSystem(); }

NTKERNELAPI VOID FsRtlReleaseFileForModWrite (  IN PFILE_OBJECT  FileObject, IN PERESOURCE  ResourceToRelease )

Definition at line 2342 of file fastio.c. References ASSERT, _DEVICE_OBJECT::DriverObject, ExReleaseResource, _DRIVER_OBJECT::FastIoDispatch, IoGetBaseFileSystemDeviceObject(), NTSTATUS(), NULL, PAGED_CODE, _FAST_IO_DISPATCH::ReleaseForModWrite, _FAST_IO_DISPATCH::SizeOfFastIoDispatch, and Status. Referenced by MiWriteComplete(). : This routine releases a file system resource previously acquired for the modified page writer. Arguments: FileObject - Pointer to the file object being written. ResourceToRelease - Supplies the resource to release. Not defined if FALSE is returned. Return Value: None. --*/ { PDEVICE_OBJECT DeviceObject; PFAST_IO_DISPATCH FastIoDispatch; NTSTATUS Status = STATUS_INVALID_DEVICE_REQUEST; PAGED_CODE(); // // First see if we have to call the file system. Note that in the case // of layered file systems, the layered file system might have the // dispatch routine, but the file system on which it is layered on may // not. In that case, the layered file system will return // STATUS_INVALID_DEVICE_REQUEST. // DeviceObject = IoGetBaseFileSystemDeviceObject( FileObject ); FastIoDispatch = DeviceObject->DriverObject->FastIoDispatch; if ((FastIoDispatch->SizeOfFastIoDispatch > FIELD_OFFSET( FAST_IO_DISPATCH, ReleaseForModWrite )) && (FastIoDispatch->ReleaseForModWrite != NULL)) { Status = FastIoDispatch->ReleaseForModWrite( FileObject, ResourceToRelease, DeviceObject ); } ASSERT( (Status == STATUS_SUCCESS) || (Status == STATUS_INVALID_DEVICE_REQUEST) ); if (Status == STATUS_INVALID_DEVICE_REQUEST) { ExReleaseResource( ResourceToRelease ); } }

NTSTATUS FsRtlSetFileSize (  IN PFILE_OBJECT  FileObject, IN OUT PLARGE_INTEGER  FileSize )

Definition at line 2864 of file fastio.c. References _IRP::AssociatedIrp, Buffer, _IO_STACK_LOCATION::DeviceObject, Event(), Executive, FALSE, _IO_STACK_LOCATION::FileObject, _IRP::Flags, IoAllocateIrp(), IoCallDriver, IoGetNextIrpStackLocation, IoGetRelatedDeviceObject(), Irp, IRP_MJ_SET_INFORMATION, IRP_PAGING_IO, IRP_SYNCHRONOUS_PAGING_IO, KeInitializeEvent, KernelMode, KeWaitForSingleObject(), _IO_STACK_LOCATION::MajorFunction, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, _IO_STACK_LOCATION::Parameters, PsGetCurrentThread, _IRP::RequestorMode, _DEVICE_OBJECT::StackSize, Status, _IRP::Tail, _IRP::UserEvent, and _IRP::UserIosb. Referenced by MiCreateDataFileMap(), and MmExtendSection(). 02871 : 02872 02873 This routine is used to call the File System to update FileSize 02874 for a file. 02875 02876 It does this without acquiring the file object lock on synchronous file 02877 objects. This routine is therefore safe to call if you already own 02878 file system resources, while IoSetInformation could (and does) lead 02879 to deadlocks. 02880 02881 Arguments: 02882 02883 FileObject - A pointer to a referenced file object. 02884 02885 ValidDataLength - Pointer to new FileSize. 02886 02887 Return Value: 02888 02889 Status of operation. 02890 02891 --*/ 02892 02893 { 02894 PIO_STACK_LOCATION IrpSp; 02895 PDEVICE_OBJECT DeviceObject; 02896 NTSTATUS Status; 02897 FILE_END_OF_FILE_INFORMATION Buffer; 02898 IO_STATUS_BLOCK IoStatus; 02899 KEVENT Event; 02900 PIRP Irp; 02901 02902 PAGED_CODE(); 02903 02904 // 02905 // Copy FileSize to our buffer. 02906 // 02907 02908 Buffer.EndOfFile = *FileSize; 02909 02910 // 02911 // Initialize the event. 02912 // 02913 02914 KeInitializeEvent( &Event, NotificationEvent, FALSE ); 02915 02916 // 02917 // Begin by getting a pointer to the device object that the file resides 02918 // on. 02919 // 02920 02921 DeviceObject = IoGetRelatedDeviceObject( FileObject ); 02922 02923 // 02924 // Allocate an I/O Request Packet (IRP) for this in-page operation. 02925 // 02926 02927 Irp = IoAllocateIrp( DeviceObject->StackSize, FALSE ); 02928 if (Irp == NULL) { 02929 02930 return STATUS_INSUFFICIENT_RESOURCES; 02931 } 02932 02933 // 02934 // Get a pointer to the first stack location in the packet. This location 02935 // will be used to pass the function codes and parameters to the first 02936 // driver. 02937 // 02938 02939 IrpSp = IoGetNextIrpStackLocation( Irp ); 02940 02941 // 02942 // Fill in the IRP according to this request, setting the flags to 02943 // just cause IO to set the event and deallocate the Irp. 02944 // 02945 02946 Irp->Flags = IRP_PAGING_IO | IRP_SYNCHRONOUS_PAGING_IO; 02947 Irp->RequestorMode = KernelMode; 02948 Irp->UserIosb = &IoStatus; 02949 Irp->UserEvent = &Event; 02950 Irp->Tail.Overlay.OriginalFileObject = FileObject; 02951 Irp->Tail.Overlay.Thread = PsGetCurrentThread(); 02952 Irp->AssociatedIrp.SystemBuffer = &Buffer; 02953 02954 // 02955 // Fill in the normal set file parameters. 02956 // 02957 02958 IrpSp->MajorFunction = IRP_MJ_SET_INFORMATION; 02959 IrpSp->FileObject = FileObject; 02960 IrpSp->DeviceObject = DeviceObject; 02961 IrpSp->Parameters.SetFile.Length = sizeof(FILE_END_OF_FILE_INFORMATION); 02962 IrpSp->Parameters.SetFile.FileInformationClass = FileEndOfFileInformation; 02963 02964 // 02965 // Queue the packet to the appropriate driver based on whether or not there 02966 // is a VPB associated with the device. This routine should not raise. 02967 // 02968 02969 Status = IoCallDriver( DeviceObject, Irp ); 02970 02971 // 02972 // If pending is returned (which is a successful status), 02973 // we must wait for the request to complete. 02974 // 02975 02976 if (Status == STATUS_PENDING) { 02977 KeWaitForSingleObject( &Event, 02978 Executive, 02979 KernelMode, 02980 FALSE, 02981 (PLARGE_INTEGER)NULL); 02982 } 02983 02984 // 02985 // If we got an error back in Status, then the Iosb 02986 // was not written, so we will just copy the status 02987 // there, then test the final status after that. 02988 // 02989 02990 if (!NT_SUCCESS(Status)) { 02991 IoStatus.Status = Status; 02992 } 02993 02994 return IoStatus.Status; 02995 } }

---