fatdata.c File Reference

#include "fatprocs.h"

Include dependency graph for fatdata.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (FAT_BUG_CHECK_FATDATA)
#define	Dbg   (DEBUG_TRACE_CATCH_EXCEPTIONS)

Functions
ULONG	FatExceptionFilter (IN PIRP_CONTEXT IrpContext, IN PEXCEPTION_POINTERS ExceptionPointer)
	_Requires_lock_held_ (_Global_critical_region_)
VOID	FatCompleteRequest_Real (IN PIRP_CONTEXT IrpContext OPTIONAL, IN PIRP Irp OPTIONAL, IN NTSTATUS Status)
BOOLEAN	FatIsIrpTopLevel (IN PIRP Irp)
	_Function_class_ (FAST_IO_CHECK_IF_POSSIBLE)
	_Function_class_ (FAST_IO_QUERY_BASIC_INFO)
	_Function_class_ (FAST_IO_QUERY_STANDARD_INFO)
	_Function_class_ (FAST_IO_QUERY_NETWORK_OPEN_INFO)

Variables
FAT_DATA	FatData
PDEVICE_OBJECT	FatDiskFileSystemDeviceObject
PDEVICE_OBJECT	FatCdromFileSystemDeviceObject
LARGE_INTEGER	FatLargeZero = {0,0}
LARGE_INTEGER	FatMaxLarge = {MAXULONG,MAXLONG}
LARGE_INTEGER	Fat30Milliseconds = {(ULONG)(-30 * 1000 * 10), -1}
LARGE_INTEGER	Fat100Milliseconds = {(ULONG)(-30 * 1000 * 10), -1}
LARGE_INTEGER	FatOneDay = {0x2a69c000, 0xc9}
LARGE_INTEGER	FatJanOne1980 = {0xe1d58000,0x01a8e79f}
LARGE_INTEGER	FatDecThirtyOne1979 = {0xb76bc000,0x01a8e6d6}
FAT_TIME_STAMP	FatTimeJanOne1980 = {{0,0,0},{1,1,0}}
LARGE_INTEGER	FatMagic10000 = {0xe219652c, 0xd1b71758}
LARGE_INTEGER	FatMagic86400000 = {0xfa67b90e, 0xc6d750eb}
FAST_IO_DISPATCH	FatFastIoDispatch
NPAGED_LOOKASIDE_LIST	FatIrpContextLookasideList
NPAGED_LOOKASIDE_LIST	FatNonPagedFcbLookasideList
NPAGED_LOOKASIDE_LIST	FatEResourceLookasideList
SLIST_HEADER	FatCloseContextSList
FAST_MUTEX	FatCloseQueueMutex
PMDL	FatReserveMdl = NULL
KEVENT	FatReserveEvent
LOGICAL	FatDiskAccountingEnabled = FALSE

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (FAT_BUG_CHECK_FATDATA)

Definition at line 22 of file fatdata.c.

Dbg

#define Dbg   (DEBUG_TRACE_CATCH_EXCEPTIONS)

Definition at line 28 of file fatdata.c.

Function Documentation

_Function_class_() [1/4]

_Function_class_

(

FAST_IO_CHECK_IF_POSSIBLE

)

Definition at line 857 of file fatdata.c.

{
    PVCB Vcb;
    PFCB Fcb;
    PCCB Ccb;
 
    LARGE_INTEGER LargeLength;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( DeviceObject );
    UNREFERENCED_PARAMETER( IoStatus );
    UNREFERENCED_PARAMETER( Wait );
    //
    //  Decode the file object to get our fcb, the only one we want
    //  to deal with is a UserFileOpen
    //
 
    if (FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb ) != UserFileOpen) {
 
        return FALSE;
    }
 
    LargeLength.QuadPart = Length;
 
    //
    //  Based on whether this is a read or write operation we call
    //  fsrtl check for read/write
    //
 
    if (CheckForReadOperation) {
 
        if (FsRtlFastCheckLockForRead( &Fcb->Specific.Fcb.FileLock,
                                       FileOffset,
                                       &LargeLength,
                                       LockKey,
                                       FileObject,
                                       PsGetCurrentProcess() )) {
 
            return TRUE;
        }
 
    } else {
 
 
        //
        //  Also check for a write-protected volume here.
        //
 
        if (!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_WRITE_PROTECTED) &&
            FsRtlFastCheckLockForWrite( &Fcb->Specific.Fcb.FileLock,
                                        FileOffset,
                                        &LargeLength,
                                        LockKey,
                                        FileObject,
                                        PsGetCurrentProcess() )) {
 
            return TRUE;
        }
    }
 
    return FALSE;
}

_Function_class_() [2/4]

_Function_class_

(

FAST_IO_QUERY_BASIC_INFO

)

Definition at line 966 of file fatdata.c.

{
    BOOLEAN Results = FALSE;
    IRP_CONTEXT IrpContext;
 
    TYPE_OF_OPEN TypeOfOpen;
    PVCB Vcb;
    PFCB Fcb;
    PCCB Ccb;
 
    BOOLEAN FcbAcquired = FALSE;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER( DeviceObject );
 
    //
    //  Prepare the dummy irp context
    //
 
    RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT) );
    IrpContext.NodeTypeCode = FAT_NTC_IRP_CONTEXT;
    IrpContext.NodeByteSize = sizeof(IRP_CONTEXT);
 
    if (Wait) {
 
        SetFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
 
    } else {
 
        ClearFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
    }
 
    //
    //  Determine the type of open for the input file object and only accept
    //  the user file or directory open
    //
 
    TypeOfOpen = FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb );
 
    if ((TypeOfOpen != UserFileOpen) && (TypeOfOpen != UserDirectoryOpen)) {
 
        return Results;
    }
 
    FsRtlEnterFileSystem();
 
    //
    //  Get access to the Fcb but only if it is not the paging file
    //
 
    if (!FlagOn( Fcb->FcbState, FCB_STATE_PAGING_FILE )) {
 
        if (!ExAcquireResourceSharedLite( Fcb->Header.Resource, Wait )) {
 
            FsRtlExitFileSystem();
            return Results;
        }
 
        FcbAcquired = TRUE;
    }
 
    _SEH2_TRY {
 
        //
        //  If the Fcb is not in a good state, return FALSE.
        //
 
        if (Fcb->FcbCondition != FcbGood) {
 
            try_return( Results );
        }
 
        Buffer->FileAttributes = 0;
 
        //
        //  If the fcb is not the root dcb then we will fill in the
        //  buffer otherwise it is all setup for us.
        //
 
        if (NodeType(Fcb) != FAT_NTC_ROOT_DCB) {
 
            //
            //  Extract the data and fill in the non zero fields of the output
            //  buffer
            //
 
            Buffer->LastWriteTime = Fcb->LastWriteTime;
            Buffer->CreationTime = Fcb->CreationTime;
            Buffer->LastAccessTime = Fcb->LastAccessTime;
 
            //
            //  Zero out the field we don't support.
            //
 
            Buffer->ChangeTime.QuadPart = 0;
            Buffer->FileAttributes = Fcb->DirentFatFlags;
 
        } else {
 
            Buffer->LastWriteTime.QuadPart = 0;
            Buffer->CreationTime.QuadPart = 0;
            Buffer->LastAccessTime.QuadPart = 0;
            Buffer->ChangeTime.QuadPart = 0;
 
            Buffer->FileAttributes = FILE_ATTRIBUTE_DIRECTORY;
        }
 
 
        //
        //  If the temporary flag is set, then set it in the buffer.
        //
 
        if (FlagOn( Fcb->FcbState, FCB_STATE_TEMPORARY )) {
 
            SetFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_TEMPORARY );
        }
 
        //
        //  If no attributes were set, set the normal bit.
        //
 
        if (Buffer->FileAttributes == 0) {
 
            Buffer->FileAttributes = FILE_ATTRIBUTE_NORMAL;
        }
 
        IoStatus->Status = STATUS_SUCCESS;
        IoStatus->Information = sizeof(FILE_BASIC_INFORMATION);
 
        Results = TRUE;
 
    try_exit: NOTHING;
    } _SEH2_FINALLY {
 
        if (FcbAcquired) { ExReleaseResourceLite( Fcb->Header.Resource ); }
 
        FsRtlExitFileSystem();
    } _SEH2_END;
 
    //
    //  And return to our caller
    //
 
    return Results;
}

_Function_class_() [3/4]

_Function_class_

(

FAST_IO_QUERY_NETWORK_OPEN_INFO

)

Definition at line 1307 of file fatdata.c.

{
    BOOLEAN Results = FALSE;
    IRP_CONTEXT IrpContext;
 
    TYPE_OF_OPEN TypeOfOpen;
    PVCB Vcb;
    PFCB Fcb;
    PCCB Ccb;
 
    BOOLEAN FcbAcquired = FALSE;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    //
    //  Prepare the dummy irp context
    //
 
    RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT) );
    IrpContext.NodeTypeCode = FAT_NTC_IRP_CONTEXT;
    IrpContext.NodeByteSize = sizeof(IRP_CONTEXT);
 
    if (Wait) {
 
        SetFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
 
    } else {
 
        ClearFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
    }
 
    //
    //  Determine the type of open for the input file object and only accept
    //  the user file or directory open
    //
 
    TypeOfOpen = FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb );
 
    if ((TypeOfOpen != UserFileOpen) && (TypeOfOpen != UserDirectoryOpen)) {
 
        return Results;
    }
 
    FsRtlEnterFileSystem();
 
    //
    //  Get access to the Fcb but only if it is not the paging file
    //
 
    if (!FlagOn( Fcb->FcbState, FCB_STATE_PAGING_FILE )) {
 
        if (!ExAcquireResourceSharedLite( Fcb->Header.Resource, Wait )) {
 
            FsRtlExitFileSystem();
            return Results;
        }
 
        FcbAcquired = TRUE;
    }
 
    _SEH2_TRY {
 
        //
        //  If the Fcb is not in a good state, return FALSE.
        //
 
        if (Fcb->FcbCondition != FcbGood) {
 
            try_return( Results );
        }
 
        //
        //  Extract the data and fill in the non zero fields of the output
        //  buffer
        //
 
        //
        //  Default the field we don't support to a reasonable value.
        //
 
        ExLocalTimeToSystemTime( &FatJanOne1980,
                                 &Buffer->ChangeTime );
 
        Buffer->FileAttributes = Fcb->DirentFatFlags;
 
        if (Fcb->Header.NodeTypeCode == FAT_NTC_ROOT_DCB) {
 
            //
            //  Reuse the default for the root dir.
            //
 
            Buffer->CreationTime =
            Buffer->LastAccessTime =
            Buffer->LastWriteTime = Buffer->ChangeTime;
 
        } else {
 
            Buffer->LastWriteTime = Fcb->LastWriteTime;
            Buffer->CreationTime = Fcb->CreationTime;
            Buffer->LastAccessTime = Fcb->LastAccessTime;
 
        }
 
        //
        //  If the temporary flag is set, then set it in the buffer.
        //
 
        if (FlagOn( Fcb->FcbState, FCB_STATE_TEMPORARY )) {
 
            SetFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_TEMPORARY );
        }
 
 
 
        //
        //  If no attributes were set, set the normal bit.
        //
 
        if (Buffer->FileAttributes == 0) {
 
            Buffer->FileAttributes = FILE_ATTRIBUTE_NORMAL;
        }
 
        if (NodeType(Fcb) == FAT_NTC_FCB) {
 
            //
            //  If we don't already know the allocation size, we cannot
            //  lock it up in the fast path.
            //
 
            if (Fcb->Header.AllocationSize.QuadPart == FCB_LOOKUP_ALLOCATIONSIZE_HINT) {
 
                try_return( Results );
            }
 
            Buffer->AllocationSize = Fcb->Header.AllocationSize;
            Buffer->EndOfFile = Fcb->Header.FileSize;
 
        } else {
 
            Buffer->AllocationSize = FatLargeZero;
            Buffer->EndOfFile = FatLargeZero;
        }
 
        IoStatus->Status = STATUS_SUCCESS;
        IoStatus->Information = sizeof(FILE_NETWORK_OPEN_INFORMATION);
 
        Results = TRUE;
 
    try_exit: NOTHING;
    } _SEH2_FINALLY {
 
        if (FcbAcquired) { ExReleaseResourceLite( Fcb->Header.Resource ); }
 
        FsRtlExitFileSystem();
    } _SEH2_END;
 
    //
    //  And return to our caller
    //
 
    return Results;
}

_Function_class_() [4/4]

_Function_class_

(

FAST_IO_QUERY_STANDARD_INFO

)

Definition at line 1146 of file fatdata.c.

{
    BOOLEAN Results = FALSE;
    IRP_CONTEXT IrpContext;
 
    TYPE_OF_OPEN TypeOfOpen;
    PVCB Vcb;
    PFCB Fcb;
    PCCB Ccb;
 
    BOOLEAN FcbAcquired = FALSE;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    //
    //  Prepare the dummy irp context
    //
 
    RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT) );
    IrpContext.NodeTypeCode = FAT_NTC_IRP_CONTEXT;
    IrpContext.NodeByteSize = sizeof(IRP_CONTEXT);
 
    if (Wait) {
 
        SetFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
 
    } else {
 
        ClearFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
    }
 
    //
    //  Determine the type of open for the input file object and only accept
    //  the user file or directory open
    //
 
    TypeOfOpen = FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb );
 
    if ((TypeOfOpen != UserFileOpen) && (TypeOfOpen != UserDirectoryOpen)) {
 
        return Results;
    }
 
    //
    //  Get access to the Fcb but only if it is not the paging file
    //
 
    FsRtlEnterFileSystem();
 
    if (!FlagOn( Fcb->FcbState, FCB_STATE_PAGING_FILE )) {
 
        if (!ExAcquireResourceSharedLite( Fcb->Header.Resource, Wait )) {
 
            FsRtlExitFileSystem();
            return Results;
        }
 
        FcbAcquired = TRUE;
    }
 
    _SEH2_TRY {
 
        //
        //  If the Fcb is not in a good state, return FALSE.
        //
 
        if (Fcb->FcbCondition != FcbGood) {
 
            try_return( Results );
        }
 
        Buffer->NumberOfLinks = 1;
        Buffer->DeletePending = BooleanFlagOn( Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE );
 
        //
        //  Case on whether this is a file or a directory, and extract
        //  the information and fill in the fcb/dcb specific parts
        //  of the output buffer.
        //
 
        if (NodeType(Fcb) == FAT_NTC_FCB) {
 
            //
            //  If we don't alread know the allocation size, we cannot look
            //  it up in the fast path.
            //
 
            if (Fcb->Header.AllocationSize.QuadPart == FCB_LOOKUP_ALLOCATIONSIZE_HINT) {
 
                try_return( Results );
            }
 
            Buffer->AllocationSize = Fcb->Header.AllocationSize;
            Buffer->EndOfFile = Fcb->Header.FileSize;
 
            Buffer->Directory = FALSE;
 
        } else {
 
            Buffer->AllocationSize = FatLargeZero;
            Buffer->EndOfFile = FatLargeZero;
 
            Buffer->Directory = TRUE;
        }
 
        IoStatus->Status = STATUS_SUCCESS;
        IoStatus->Information = sizeof(FILE_STANDARD_INFORMATION);
 
        Results = TRUE;
 
    try_exit: NOTHING;
    } _SEH2_FINALLY {
 
        if (FcbAcquired) { ExReleaseResourceLite( Fcb->Header.Resource ); }
 
        FsRtlExitFileSystem();
    } _SEH2_END;
 
    //
    //  And return to our caller
    //
 
    return Results;
}

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 320 of file fatdata.c.

{
    PVCB Vcb;
    PIO_STACK_LOCATION IrpSp;
    FAT_VOLUME_STATE TransitionState = VolumeDirty;
    ULONG SavedFlags = 0;
 
    PAGED_CODE();
 
    DebugTrace(0, Dbg, "FatProcessException\n", 0);
 
    //
    //  If there is not an irp context, we must have had insufficient resources.
    //
 
    if ( !ARGUMENT_PRESENT( IrpContext ) ) {
 
        FatCompleteRequest( FatNull, Irp, ExceptionCode );
 
        return ExceptionCode;
    }
 
    //
    //  Get the real exception status from IrpContext->ExceptionStatus, and
    //  reset it.
    //
 
    ExceptionCode = IrpContext->ExceptionStatus;
    FatResetExceptionState( IrpContext );
 
    //
    //  If this is an Mdl write request, then take care of the Mdl
    //  here so that things get cleaned up properly.  Cc now leaves
    //  the MDL in place so a filesystem can retry after clearing an
    //  internal condition (FAT does not).
    //
 
    if ((IrpContext->MajorFunction == IRP_MJ_WRITE) &&
        (FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE_MDL ) == IRP_MN_COMPLETE_MDL) &&
        (Irp->MdlAddress != NULL)) {
 
        PIO_STACK_LOCATION LocalIrpSp = IoGetCurrentIrpStackLocation(Irp);
 
        CcMdlWriteAbort( LocalIrpSp->FileObject, Irp->MdlAddress );
        Irp->MdlAddress = NULL;
    }
 
    //
    //  If we are going to post the request, we may have to lock down the
    //  user's buffer, so do it here in a try except so that we failed the
    //  request if the LockPages fails.
    //
    //  Also unpin any repinned Bcbs, protected by the try {} except {} filter.
    //
 
    _SEH2_TRY {
 
        SavedFlags = IrpContext->Flags;
 
        //
        //  Make sure we don't try to write through Bcbs
        //
 
        SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_WRITE_THROUGH);
 
        FatUnpinRepinnedBcbs( IrpContext );
 
        IrpContext->Flags = SavedFlags;
 
        //
        //  If we will have to post the request, do it here.  Note
        //  that the last thing FatPrePostIrp() does is mark the Irp pending,
        //  so it is critical that we actually return PENDING.  Nothing
        //  from this point to return can fail, so we are OK.
        //
        //  We cannot do a verify operations at APC level because we
        //  have to wait for Io operations to complete.
        //
 
        if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL) &&
#if (NTDDI_VERSION >= NTDDI_VISTA)
            (((ExceptionCode == STATUS_VERIFY_REQUIRED) && KeAreAllApcsDisabled()) ||
#else
            (((ExceptionCode == STATUS_VERIFY_REQUIRED) && (KeGetCurrentIrql() >= APC_LEVEL)) ||
#endif
             (ExceptionCode == STATUS_CANT_WAIT))) {
 
            ExceptionCode = FatFsdPostRequest( IrpContext, Irp );
        }
 
    } _SEH2_EXCEPT( FatExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() ) ) {
 
        ExceptionCode = IrpContext->ExceptionStatus;
        IrpContext->ExceptionStatus = 0;
 
        IrpContext->Flags = SavedFlags;
    } _SEH2_END;
 
    //
    //  If we posted the request, just return here.
    //
 
    if (ExceptionCode == STATUS_PENDING) {
 
        return ExceptionCode;
    }
 
    Irp->IoStatus.Status = ExceptionCode;
 
 
    //
    //  If this request is not a "top-level" irp, just complete it.
    //
 
    if (FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL)) {
 
        //
        //  If there is a cache operation above us, commute verify
        //  to a lock conflict.  This will cause retries so that
        //  we have a chance of getting through without needing
        //  to return an unaesthetic error for the operation.
        //
 
        if (IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP &&
            ExceptionCode == STATUS_VERIFY_REQUIRED) {
 
            ExceptionCode = STATUS_FILE_LOCK_CONFLICT;
        }
 
        FatCompleteRequest( IrpContext, Irp, ExceptionCode );
 
        return ExceptionCode;
    }
 
    if (IoIsErrorUserInduced(ExceptionCode)) {
 
        //
        //  Check for the various error conditions that can be caused by,
        //  and possibly resolved by the user.
        //
 
        if (ExceptionCode == STATUS_VERIFY_REQUIRED) {
 
            PDEVICE_OBJECT Device = NULL;
 
            DebugTrace(0, Dbg, "Perform Verify Operation\n", 0);
 
            //
            //  Now we are at the top level file system entry point.
            //
            //  Grab the device to verify from the thread local storage
            //  and stick it in the information field for transportation
            //  to the fsp.  We also clear the field at this time.
            //
 
            Device = IoGetDeviceToVerify( Irp->Tail.Overlay.Thread );
            IoSetDeviceToVerify( Irp->Tail.Overlay.Thread, NULL );
 
            if ( Device == NULL ) {
 
                Device = IoGetDeviceToVerify( PsGetCurrentThread() );
                IoSetDeviceToVerify( PsGetCurrentThread(), NULL );
 
                NT_ASSERT( Device != NULL );
            }
 
            //
            //  It turns out some storage drivers really do set invalid non-NULL device
            //  objects to verify.
            //
            //  To work around this, completely ignore the device to verify in the thread,
            //  and just use our real device object instead.
            //
 
            if (IrpContext->Vcb) {
 
                Device = IrpContext->Vcb->Vpb->RealDevice;
 
            } else {
 
                //
                // For FSCTLs, IrpContext->Vcb may not be populated, so get the IrpContext->RealDevice instead
                //
 
                Device = IrpContext->RealDevice;
            }
 
            //
            //  Let's not BugCheck just because the device to verify is somehow still NULL.
            //
 
            if (Device == NULL) {
 
                ExceptionCode = STATUS_DRIVER_INTERNAL_ERROR;
 
                FatCompleteRequest( IrpContext, Irp, ExceptionCode );
 
                return ExceptionCode;
            }
 
            //
            //  FatPerformVerify() will do the right thing with the Irp.
 
            return FatPerformVerify( IrpContext, Irp, Device );
        }
 
        //
        //  The other user induced conditions generate an error unless
        //  they have been disabled for this request.
        //
 
        if (FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS)) {
 
            FatCompleteRequest( IrpContext, Irp, ExceptionCode );
 
            return ExceptionCode;
 
        } else {
 
            //
            //  Generate a pop-up
            //
 
            PDEVICE_OBJECT RealDevice = NULL;
            PVPB Vpb;
            PETHREAD Thread;
 
            if (IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL) {
 
                Vpb = IoGetCurrentIrpStackLocation(Irp)->FileObject->Vpb;
 
            } else {
 
                Vpb = NULL;
            }
 
            //
            //  The device to verify is either in my thread local storage
            //  or that of the thread that owns the Irp.
            //
 
            Thread = Irp->Tail.Overlay.Thread;
            RealDevice = IoGetDeviceToVerify( Thread );
 
            if ( RealDevice == NULL ) {
 
                Thread = PsGetCurrentThread();
                RealDevice = IoGetDeviceToVerify( Thread );
 
                NT_ASSERT( RealDevice != NULL );
            }
 
            //
            //  It turns out some storage drivers really do set invalid non-NULL device
            //  objects to verify.
            //
            //  To work around this, completely ignore the device to verify in the thread,
            //  and just use our real device object instead.
            //
 
            if (IrpContext->Vcb) {
 
                RealDevice = IrpContext->Vcb->Vpb->RealDevice;
 
            } else {
 
                //
                // For FSCTLs, IrpContext->Vcb may not be populated, so get the IrpContext->RealDevice instead
                //
 
                RealDevice = IrpContext->RealDevice;
            }
 
            //
            //  Let's not BugCheck just because the device to verify is somehow still NULL.
            //
 
            if (RealDevice == NULL) {
 
                FatCompleteRequest( IrpContext, Irp, ExceptionCode );
 
                return ExceptionCode;
            }
 
            //
            //  This routine actually causes the pop-up.  It usually
            //  does this by queuing an APC to the callers thread,
            //  but in some cases it will complete the request immediately,
            //  so it is very important to IoMarkIrpPending() first.
            //
 
            IoMarkIrpPending( Irp );
            IoRaiseHardError( Irp, Vpb, RealDevice );
 
            //
            //  We will be handing control back to the caller here, so
            //  reset the saved device object.
            //
 
            IoSetDeviceToVerify( Thread, NULL );
 
            //
            //  The Irp will be completed by Io or resubmitted.  In either
            //  case we must clean up the IrpContext here.
            //
 
            FatDeleteIrpContext( IrpContext );
            return STATUS_PENDING;
        }
    }
 
    //
    //  This is just a run of the mill error.  If is a STATUS that we
    //  raised ourselves, and the information would be use for the
    //  user, raise an informational pop-up.
    //
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
    Vcb = IrpContext->Vcb;
 
    //
    //  Now, if the Vcb is unknown to us this means that the error was raised
    //  in the process of a mount and before we even had a chance to build
    //  a full Vcb - and was really handled there.
    //
 
    if (Vcb != NULL) {
 
        if ( !FatDeviceIsFatFsdo( IrpSp->DeviceObject) &&
             !NT_SUCCESS(ExceptionCode) &&
             !FsRtlIsTotalDeviceFailure(ExceptionCode) ) {
 
            TransitionState = VolumeDirtyWithSurfaceTest;
        }
 
        //
        //  If this was a STATUS_FILE_CORRUPT or similar error indicating some
        //  nastiness out on the media, then mark the volume permanently dirty.
        //
 
        if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS) &&
            ( TransitionState == VolumeDirtyWithSurfaceTest ||
              (ExceptionCode == STATUS_FILE_CORRUPT_ERROR) ||
              (ExceptionCode == STATUS_DISK_CORRUPT_ERROR) ||
              (ExceptionCode == STATUS_EA_CORRUPT_ERROR) ||
              (ExceptionCode == STATUS_INVALID_EA_NAME) ||
              (ExceptionCode == STATUS_EA_LIST_INCONSISTENT) ||
              (ExceptionCode == STATUS_NO_EAS_ON_FILE) )) {
 
            NT_ASSERT( NodeType(Vcb) == FAT_NTC_VCB );
            NT_ASSERT( !FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL));
 
            SetFlag( Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY );
            SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
 
            //
            //  Do the "dirty" work, ignoring any error.  We need to take the Vcb here
            //  to synchronize against the verify path tearing things down, since
            //  we dropped all synchronization when backing up due to the exception.
            //
 
            FatAcquireExclusiveVcbNoOpCheck( IrpContext, Vcb);
 
            _SEH2_TRY {
 
                if (VcbGood == Vcb->VcbCondition) {
 
                    FatMarkVolume( IrpContext, Vcb, TransitionState );
                }
            }
            _SEH2_EXCEPT( FatExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() ) ) {
 
                NOTHING;
            } _SEH2_END;
 
            FatReleaseVcb( IrpContext, Vcb);
        }
    }
 
    FatCompleteRequest( IrpContext, Irp, ExceptionCode );
 
    return ExceptionCode;
}

FatCompleteRequest_Real()

VOID FatCompleteRequest_Real	(	IN PIRP_CONTEXT IrpContext	OPTIONAL,
		IN PIRP Irp	OPTIONAL,
		IN NTSTATUS	Status
	)

Definition at line 733 of file fatdata.c.

{
    PAGED_CODE();
 
#if DBG
    if ( (FatBreakOnInterestingIrpCompletion != 0) && (Status == FatBreakOnInterestingIrpCompletion) ) {
        DbgBreakPoint();
    }
 
#endif
 
    //
    //  If we have an Irp Context then unpin all of the repinned bcbs
    //  we might have collected.
    //
 
    if (IrpContext != NULL) {
 
        NT_ASSERT( IrpContext->Repinned.Bcb[0] == NULL );
 
        FatUnpinRepinnedBcbs( IrpContext );
    }
 
    //
    //  Delete the Irp context before completing the IRP so if
    //  we run into some of the asserts, we can still backtrack
    //  through the IRP.
    //
 
    if (IrpContext != NULL) {
 
        FatDeleteIrpContext( IrpContext );
    }
 
    //
    //  If we have an Irp then complete the irp.
    //
 
    if (Irp != NULL) {
 
        //
        //  We got an error, so zero out the information field before
        //  completing the request if this was an input operation.
        //  Otherwise IopCompleteRequest will try to copy to the user's buffer.
        //
 
        if ( NT_ERROR(Status) &&
             FlagOn(Irp->Flags, IRP_INPUT_OPERATION) ) {
 
            Irp->IoStatus.Information = 0;
        }
 
        Irp->IoStatus.Status = Status;
 
        IoCompleteRequest( Irp, IO_DISK_INCREMENT );
    }
 
    return;
}

FatExceptionFilter()

ULONG FatExceptionFilter	(	IN PIRP_CONTEXT	IrpContext,
		IN PEXCEPTION_POINTERS	ExceptionPointer
	)

Definition at line 204 of file fatdata.c.

{
    NTSTATUS ExceptionCode;
 
    ExceptionCode = ExceptionPointer->ExceptionRecord->ExceptionCode;
    DebugTrace(0, DEBUG_TRACE_UNWIND, "FatExceptionFilter %X\n", ExceptionCode);
    DebugDump("FatExceptionFilter\n", Dbg, NULL );
 
#if DBG
 
    if( FatBreakOnInterestingExceptionStatus != 0 && ExceptionCode == FatBreakOnInterestingExceptionStatus ) {
        DbgBreakPoint();
    }
 
#endif
 
    //
    // If the exception is STATUS_IN_PAGE_ERROR, get the I/O error code
    // from the exception record.
    //
 
    if (ExceptionCode == STATUS_IN_PAGE_ERROR) {
        if (ExceptionPointer->ExceptionRecord->NumberParameters >= 3) {
            ExceptionCode = (NTSTATUS)ExceptionPointer->ExceptionRecord->ExceptionInformation[2];
        }
    }
 
    //
    //  If there is not an irp context, we must have had insufficient resources.
    //
 
    if ( !ARGUMENT_PRESENT( IrpContext ) ) {
 
        if (!FsRtlIsNtstatusExpected( ExceptionCode )) {
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
            FatBugCheck( (ULONG_PTR)ExceptionPointer->ExceptionRecord,
                         (ULONG_PTR)ExceptionPointer->ContextRecord,
                         (ULONG_PTR)ExceptionPointer->ExceptionRecord->ExceptionAddress );
        }
 
        return EXCEPTION_EXECUTE_HANDLER;
    }
 
    //
    //  For the purposes of processing this exception, let's mark this
    //  request as being able to wait and disable  write through if we
    //  aren't posting it.
    //
 
    SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
 
    if ( (ExceptionCode != STATUS_CANT_WAIT) &&
         (ExceptionCode != STATUS_VERIFY_REQUIRED) ) {
 
        SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_WRITE_THROUGH);
    }
 
    if ( IrpContext->ExceptionStatus == 0 ) {
 
        if (FsRtlIsNtstatusExpected( ExceptionCode )) {
 
            IrpContext->ExceptionStatus = ExceptionCode;
 
            return EXCEPTION_EXECUTE_HANDLER;
 
        } else {
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
            FatBugCheck( (ULONG_PTR)ExceptionPointer->ExceptionRecord,
                         (ULONG_PTR)ExceptionPointer->ContextRecord,
                         (ULONG_PTR)ExceptionPointer->ExceptionRecord->ExceptionAddress );
        }
 
    } else {
 
        //
        //  We raised this code explicitly ourselves, so it had better be
        //  expected.
        //
 
        NT_ASSERT( IrpContext->ExceptionStatus == ExceptionCode );
        NT_ASSERT( FsRtlIsNtstatusExpected( ExceptionCode ) );
    }
 
    return EXCEPTION_EXECUTE_HANDLER;
}

Referenced by _Function_class_(), _Requires_lock_held_(), FatFlushFat(), FatFspDispatch(), FatFspMarkVolumeDirtyWithRecover(), FatMultiAsyncCompletionRoutine(), and FatSingleAsyncCompletionRoutine().

FatIsIrpTopLevel()

BOOLEAN FatIsIrpTopLevel

(

IN PIRP

Irp

)

Definition at line 817 of file fatdata.c.

{
    PAGED_CODE();
 
    if ( IoGetTopLevelIrp() == NULL ) {
 
        IoSetTopLevelIrp( Irp );
 
        return TRUE;
 
    } else {
 
        return FALSE;
    }
}

Referenced by _Function_class_(), and _Requires_lock_held_().

Variable Documentation

Fat100Milliseconds

LARGE_INTEGER Fat100Milliseconds = {(ULONG)(-30 * 1000 * 10), -1}

Definition at line 71 of file fatdata.c.

Fat30Milliseconds

LARGE_INTEGER Fat30Milliseconds = {(ULONG)(-30 * 1000 * 10), -1}

Definition at line 70 of file fatdata.c.

Referenced by FatPagingFileIo().

FatCdromFileSystemDeviceObject

PDEVICE_OBJECT FatCdromFileSystemDeviceObject

Definition at line 59 of file fatdata.c.

Referenced by _Requires_lock_held_().

FatCloseContextSList

SLIST_HEADER FatCloseContextSList

Definition at line 106 of file fatdata.c.

Referenced by FatAllocateCloseContext(), and FatPreallocateCloseContext().

FatCloseQueueMutex

FAST_MUTEX FatCloseQueueMutex

Definition at line 112 of file fatdata.c.

FatData

FAT_DATA FatData

Definition at line 56 of file fatdata.c.

Referenced by _Requires_lock_held_(), Fat8dot3ToString(), FatAllocateCloseContext(), FatBuildZeroMdl(), FatConstructDirent(), FatCreateDcb(), FatCreateFcb(), FatDeferredCleanVolume(), FatEvaluateNameCase(), FatGetDirTimes(), FatGetStatistics(), FatIsBootSectorFat(), FatMultiAsyncCompletionRoutine(), FatOpenEaFile(), FatPreallocateCloseContext(), FatQueryFsAttributeInfo(), FatSetRenameInfo(), FatSetupAllocationSupport(), FatSingleAsyncCompletionRoutine(), and FatToggleMediaEjectDisable().

FatDecThirtyOne1979

LARGE_INTEGER FatDecThirtyOne1979 = {0xb76bc000,0x01a8e6d6}

Definition at line 74 of file fatdata.c.

FatDiskAccountingEnabled

LOGICAL FatDiskAccountingEnabled = FALSE

Definition at line 129 of file fatdata.c.

Referenced by _Requires_lock_held_(), FatInitializeCacheMap(), FatMultipleAsync(), FatPagingFileIo(), FatSingleAsync(), and FatSingleNonAlignedSync().

FatDiskFileSystemDeviceObject

PDEVICE_OBJECT FatDiskFileSystemDeviceObject

Definition at line 58 of file fatdata.c.

Referenced by _Requires_lock_held_().

FatEResourceLookasideList

NPAGED_LOOKASIDE_LIST FatEResourceLookasideList

Definition at line 104 of file fatdata.c.

Referenced by FatAllocateResource(), and FatFreeResource().

FatFastIoDispatch

FAST_IO_DISPATCH FatFastIoDispatch

Definition at line 96 of file fatdata.c.

FatIrpContextLookasideList

NPAGED_LOOKASIDE_LIST FatIrpContextLookasideList

Definition at line 102 of file fatdata.c.

Referenced by FatAllocateIrpContext(), and FatFreeIrpContext().

FatJanOne1980

LARGE_INTEGER FatJanOne1980 = {0xe1d58000,0x01a8e79f}

Definition at line 73 of file fatdata.c.

Referenced by _Function_class_(), FatCreateDcb(), FatCreateFcb(), FatGetDirTimes(), and FatQueryBasicInfo().

FatLargeZero

LARGE_INTEGER FatLargeZero = {0,0}

Definition at line 62 of file fatdata.c.

Referenced by _Function_class_(), _Requires_lock_held_(), FatSyncUninitializeCacheMap(), and FatTearDownVcb().

FatMagic10000

LARGE_INTEGER FatMagic10000 = {0xe219652c, 0xd1b71758}

Definition at line 86 of file fatdata.c.

FatMagic86400000

LARGE_INTEGER FatMagic86400000 = {0xfa67b90e, 0xc6d750eb}

Definition at line 87 of file fatdata.c.

FatMaxLarge

LARGE_INTEGER FatMaxLarge = {MAXULONG,MAXLONG}

Definition at line 63 of file fatdata.c.

Referenced by _Requires_lock_held_(), FatOpenEaFile(), and FatSetupAllocationSupport().

FatNonPagedFcbLookasideList

NPAGED_LOOKASIDE_LIST FatNonPagedFcbLookasideList

Definition at line 103 of file fatdata.c.

Referenced by FatAllocateNonPagedFcb(), and FatFreeNonPagedFcb().

FatOneDay

LARGE_INTEGER FatOneDay = {0x2a69c000, 0xc9}

Definition at line 72 of file fatdata.c.

FatReserveEvent

KEVENT FatReserveEvent

Definition at line 123 of file fatdata.c.

Referenced by FatPagingFileCompletionRoutineCatch(), and FatPagingFileIo().

FatReserveMdl

PMDL FatReserveMdl = NULL

Definition at line 119 of file fatdata.c.

Referenced by FatPagingFileCompletionRoutineCatch(), and FatPagingFileIo().

FatTimeJanOne1980

FAT_TIME_STAMP FatTimeJanOne1980 = {{0,0,0},{1,1,0}}

Definition at line 83 of file fatdata.c.