close.c File Reference

#include "fatprocs.h"

Include dependency graph for close.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (FAT_BUG_CHECK_CLOSE)
#define	Dbg   (DEBUG_TRACE_CLOSE)
#define	FatAcquireCloseMutex()
#define	FatReleaseCloseMutex()

Functions
	_Requires_lock_held_ (_Global_critical_region_)
VOID NTAPI	FatCloseWorker (_In_ PDEVICE_OBJECT DeviceObject, _In_opt_ PVOID Context)

Variables
ULONG	FatMaxDelayedCloseCount

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (FAT_BUG_CHECK_CLOSE)

Definition at line 23 of file close.c.

Dbg

#define Dbg   (DEBUG_TRACE_CLOSE)

Definition at line 29 of file close.c.

FatAcquireCloseMutex

#define FatAcquireCloseMutex

(

)

Value:

    {                        \
    NT_ASSERT(KeAreApcsDisabled());                     \
    ExAcquireFastMutexUnsafe( &FatCloseQueueMutex );    \
}

Definition at line 34 of file close.c.

FatReleaseCloseMutex

#define FatReleaseCloseMutex

(

)

Value:

    {                        \
    NT_ASSERT(KeAreApcsDisabled());                     \
    ExReleaseFastMutexUnsafe( &FatCloseQueueMutex );    \
}

Definition at line 39 of file close.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 48 of file close.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PIO_STACK_LOCATION IrpSp;
    PFILE_OBJECT FileObject;
 
    PVCB Vcb;
    PFCB Fcb;
    PCCB Ccb;
    TYPE_OF_OPEN TypeOfOpen;
 
    BOOLEAN TopLevel;
    BOOLEAN VcbDeleted = FALSE;
 
    PAGED_CODE();
 
    //
    //  If we were called with our file system device object instead of a
    //  volume device object, just complete this request with STATUS_SUCCESS
    //
 
    if (FatDeviceIsFatFsdo( VolumeDeviceObject))  {
 
        Irp->IoStatus.Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = FILE_OPENED;
 
        IoCompleteRequest( Irp, IO_DISK_INCREMENT );
 
        return STATUS_SUCCESS;
    }
 
    DebugTrace(+1, Dbg, "FatFsdClose\n", 0);
 
    //
    //  Call the common Close routine
    //
 
    FsRtlEnterFileSystem();
 
    TopLevel = FatIsIrpTopLevel( Irp );
 
    //
    //  Get a pointer to the current stack location and the file object
    //
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    FileObject = IrpSp->FileObject;
 
    //
    //  Decode the file object and set the read-only bit in the Ccb.
    //
 
    TypeOfOpen = FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb );
 
    if (Ccb && IsFileObjectReadOnly(FileObject)) {
 
        SetFlag( Ccb->Flags, CCB_FLAG_READ_ONLY );
    }
 
    _SEH2_TRY {
 
        PCLOSE_CONTEXT CloseContext = NULL;
 
        //
        //  If we are top level, WAIT can be TRUE, otherwise make it FALSE
        //  to avoid deadlocks, unless this is a top
        //  level request not originating from the system process.
        //
 
        BOOLEAN Wait = TopLevel && (PsGetCurrentProcess() != FatData.OurProcess);
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
 
        //
        //  To catch the odd case where a close comes in without a preceding cleanup,
        //  call the oplock package to get rid of any oplock state.  This can only
        //  be safely done in the FSD path.
        //
 
        if ((Fcb != NULL) &&
            !FlagOn( FileObject->Flags, FO_CLEANUP_COMPLETE ) &&
            FatIsFileOplockable( Fcb )) {
 
            //
            //  This is equivalent to handling cleanup, and it always cleans up any
            //  oplock immediately.  Also, we don't need any locking of the FCB here;
            //  the oplock's own lock will be sufficient for this purpose.
            //
 
            FsRtlCheckOplockEx( FatGetFcbOplock(Fcb),
                                Irp,
                                0,
                                NULL,
                                NULL,
                                NULL );
        }
#endif
 
        //
        //  Metadata streams have had close contexts preallocated. Pull one out now, while we're
        //  guaranteed the VCB exists.
        //
 
        if ( (TypeOfOpen == VirtualVolumeFile) || (TypeOfOpen == DirectoryFile) || (TypeOfOpen == EaFile)
            ) {
 
            CloseContext = FatAllocateCloseContext( Vcb );
            NT_ASSERT( CloseContext != NULL );
            CloseContext->Free = TRUE;
 
        }
 
        //
        //  Call the common Close routine if we are not delaying this close.
        //
 
        if ((((TypeOfOpen == UserFileOpen) ||
                (TypeOfOpen == UserDirectoryOpen)) &&
                 FlagOn(Fcb->FcbState, FCB_STATE_DELAY_CLOSE) &&
                 !FatData.ShutdownStarted) ||
                (FatCommonClose( Vcb, Fcb, Ccb, TypeOfOpen, Wait, TopLevel, &VcbDeleted ) == STATUS_PENDING)) {
 
            //
            //  Ship it off to the delayed close queue if we tried to close, and got STATUS_PENDING, or
            //  if the user open told us to delay the close.
            //
 
            //
            //  Metadata streams have had close contexts preallocated. If we have a user open,
            //  pull the close context out of the Ccb.
            //
 
            if( CloseContext == NULL ) {
 
                //
                //  Free up any query template strings before using the close context fields,
                //  which overlap (union)
                //
 
                FatDeallocateCcbStrings( Ccb );
 
                CloseContext = &Ccb->CloseContext;
                CloseContext->Free = FALSE;
 
                SetFlag( Ccb->Flags, CCB_FLAG_CLOSE_CONTEXT );
            }
 
            //
            //  If the status is pending, then let's get the information we
            //  need into the close context we already have bagged, complete
            //  the request, and post it.  It is important we allocate nothing
            //  in the close path.
            //
 
            CloseContext->Vcb = Vcb;
            CloseContext->Fcb = Fcb;
            CloseContext->TypeOfOpen = TypeOfOpen;
 
            //
            //  Send it off, either to an ExWorkerThread or to the async
            //  close list.
            //
 
            FatQueueClose( CloseContext,
                           (BOOLEAN)(Fcb && FlagOn(Fcb->FcbState, FCB_STATE_DELAY_CLOSE)));
 
        } else {
 
            //
            //  The close proceeded synchronously, so for the metadata objects we
            //  can now drop the close context we preallocated.
            //
 
            if ((TypeOfOpen == VirtualVolumeFile) ||
                (TypeOfOpen == DirectoryFile) ||
                (TypeOfOpen == EaFile)
                ) {
 
                if (CloseContext != NULL) {
 
                    ExFreePool( CloseContext );
 
                }
            }
        }
 
        FatCompleteRequest( FatNull, Irp, Status );
 
    }
    _SEH2_EXCEPT(FatExceptionFilter( NULL, _SEH2_GetExceptionInformation() )) {
 
        //
        //  We had some trouble trying to perform the requested
        //  operation, so we'll abort the I/O request with the
        //  error status that we get back from the exception code.
        //
 
        Status = FatProcessException( NULL, Irp, _SEH2_GetExceptionCode() );
    } _SEH2_END;
 
    if (TopLevel) { IoSetTopLevelIrp( NULL ); }
 
    FsRtlExitFileSystem();
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatFsdClose -> %08lx\n", Status);
 
    UNREFERENCED_PARAMETER( VolumeDeviceObject );
 
    return Status;
}

FatCloseWorker()

VOID NTAPI FatCloseWorker	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_opt_ PVOID	Context
	)

Definition at line 325 of file close.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    FsRtlEnterFileSystem();
 
    FatFspClose (Context);
 
    FsRtlExitFileSystem();
}

Variable Documentation

FatMaxDelayedCloseCount

ULONG FatMaxDelayedCloseCount

Definition at line 31 of file close.c.