close.c File Reference

#include "cdprocs.h"

Include dependency graph for close.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (CDFS_BUG_CHECK_CLOSE)

Functions
	_Requires_lock_held_ (_Global_critical_region_)
VOID NTAPI	CdCloseWorker (_In_ PDEVICE_OBJECT DeviceObject, _In_opt_ PVOID Context)
VOID	CdQueueClose (_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ ULONG UserReference, _In_ BOOLEAN DelayedClose)
PIRP_CONTEXT	CdRemoveClose (_In_opt_ PVCB Vcb)

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (CDFS_BUG_CHECK_CLOSE)

Definition at line 51 of file close.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 57 of file close.c.

{
    PIRP_CONTEXT IrpContext;
    IRP_CONTEXT StackIrpContext;
 
    THREAD_CONTEXT ThreadContext = {0};
 
    PFCB Fcb;
    ULONG UserReference;
 
    ULONG VcbHoldCount = 0;
    PVCB CurrentVcb = NULL;
 
    BOOLEAN PotentialVcbTeardown = FALSE;
 
    PAGED_CODE();
 
    FsRtlEnterFileSystem();
 
    //
    //  Continue processing until there are no more closes to process.
    //
 
    while ((IrpContext = CdRemoveClose( Vcb )) != NULL) {
 
        //
        //  If we don't have an IrpContext then use the one on the stack.
        //  Initialize it for this request.
        //
 
        if (SafeNodeType( IrpContext ) != CDFS_NTC_IRP_CONTEXT ) {
 
            //
            //  Update the local values from the IrpContextLite.
            //
 
            Fcb = ((PIRP_CONTEXT_LITE) IrpContext)->Fcb;
            UserReference = ((PIRP_CONTEXT_LITE) IrpContext)->UserReference;
 
            //
            //  Update the stack irp context with the values from the
            //  IrpContextLite.
            //
 
            CdInitializeStackIrpContext( &StackIrpContext,
                                         (PIRP_CONTEXT_LITE) IrpContext );
 
            //
            //  Free the IrpContextLite.
            //
 
            CdFreeIrpContextLite( *(PVOID*)&IrpContext ); /* ReactOS Change: GCC "error: invalid lvalue in unary '&'" */
 
            //
            //  Remember we have the IrpContext from the stack.
            //
 
            IrpContext = &StackIrpContext;
 
        //
        //  Otherwise cleanup the existing IrpContext.
        //
 
        } else {
 
            //
            //  Remember the Fcb and user reference count.
            //
 
            Fcb = (PFCB) IrpContext->Irp;
            IrpContext->Irp = NULL;
 
            UserReference = (ULONG) IrpContext->ExceptionStatus;
            IrpContext->ExceptionStatus = STATUS_SUCCESS;
        }
 
        _Analysis_assume_(Fcb != NULL && Fcb->Vcb != NULL);
 
        //
        //  We have an IrpContext.  Now we need to set the top level thread
        //  context.
        //
 
        SetFlag( IrpContext->Flags, IRP_CONTEXT_FSP_FLAGS );
 
        //
        //  If we were given a Vcb then there is a request on top of this.
        //
 
        if (ARGUMENT_PRESENT( Vcb )) {
 
            ClearFlag( IrpContext->Flags,
                       IRP_CONTEXT_FLAG_TOP_LEVEL | IRP_CONTEXT_FLAG_TOP_LEVEL_CDFS );
        }
 
        CdSetThreadContext( IrpContext, &ThreadContext );
 
        //
        //  If we have hit the maximum number of requests to process without
        //  releasing the Vcb then release the Vcb now.  If we are holding
        //  a different Vcb to this one then release the previous Vcb.
        //
        //  In either case acquire the current Vcb.
        //
        //  We use the MinDelayedCloseCount from the CdData since it is
        //  a convenient value based on the system size.  Only thing we are trying
        //  to do here is prevent this routine starving other threads which
        //  may need this Vcb exclusively.
        //
        //  Note that the check for potential teardown below is unsafe.  We'll
        //  repeat later within the cddata lock.
        //
 
        PotentialVcbTeardown = !ARGUMENT_PRESENT( Vcb ) &&
                               (Fcb->Vcb->VcbCondition != VcbMounted) &&
                               (Fcb->Vcb->VcbCondition != VcbMountInProgress) &&
                               (Fcb->Vcb->VcbCleanup == 0);
 
        if (PotentialVcbTeardown ||
            (VcbHoldCount > CdData.MinDelayedCloseCount) ||
            (Fcb->Vcb != CurrentVcb)) {
 
            if (CurrentVcb != NULL) {
 
                CdReleaseVcb( IrpContext, CurrentVcb );
            }
 
            if (PotentialVcbTeardown) {
 
                CdAcquireCdData( IrpContext );
 
                //
                //  Repeat the checks with global lock held.  The volume could have
                //  been remounted while we didn't hold the lock.
                //
 
                PotentialVcbTeardown = !ARGUMENT_PRESENT( Vcb ) &&
                                       (Fcb->Vcb->VcbCondition != VcbMounted) &&
                                       (Fcb->Vcb->VcbCondition != VcbMountInProgress) &&
                                       (Fcb->Vcb->VcbCleanup == 0);
 
                if (!PotentialVcbTeardown)  {
 
                    CdReleaseCdData( IrpContext);
                }
            }
 
            CurrentVcb = Fcb->Vcb;
 
            _Analysis_assume_( CurrentVcb != NULL );
 
            CdAcquireVcbShared( IrpContext, CurrentVcb, FALSE );
 
            VcbHoldCount = 0;
 
        } else {
 
            VcbHoldCount += 1;
        }
 
        //
        //  Call our worker routine to perform the close operation.
        //
 
        CdCommonClosePrivate( IrpContext, CurrentVcb, Fcb, UserReference, FALSE );
 
        //
        //  If the reference count on this Vcb is below our residual reference
        //  then check if we should dismount the volume.
        //
 
        if (PotentialVcbTeardown) {
 
            CdReleaseVcb( IrpContext, CurrentVcb );
            CdCheckForDismount( IrpContext, CurrentVcb, FALSE );
 
            CurrentVcb = NULL;
 
            CdReleaseCdData( IrpContext );
            PotentialVcbTeardown = FALSE;
        }
 
        //
        //  Complete the current request to cleanup the IrpContext.
        //
 
        CdCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
    }
 
    //
    //  Release any Vcb we may still hold.
    //
 
    if (CurrentVcb != NULL) {
 
        CdReleaseVcb( IrpContext, CurrentVcb );
 
    }
 
#ifdef _MSC_VER
#pragma prefast(suppress:26165, "Esp:1153")
#endif
    FsRtlExitFileSystem();
}

CdCloseWorker()

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

Definition at line 657 of file close.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( DeviceObject );
    UNREFERENCED_PARAMETER( Context );
 
    CdFspClose (NULL);
}

Referenced by CdQueueClose().

CdQueueClose()

VOID CdQueueClose	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ PFCB	Fcb,
		_In_ ULONG	UserReference,
		_In_ BOOLEAN	DelayedClose
	)

Definition at line 690 of file close.c.

{
    PIRP_CONTEXT_LITE IrpContextLite = NULL;
    BOOLEAN StartWorker = FALSE;
 
    PAGED_CODE();
 
    ASSERT_IRP_CONTEXT( IrpContext );
    ASSERT_FCB( Fcb );
 
    //
    //  Start with the delayed queue request.  We can move this to the async
    //  queue if there is an allocation failure.
    //
 
    if (DelayedClose) {
 
        //
        //  Try to allocate non-paged pool for the IRP_CONTEXT_LITE.
        //
 
        IrpContextLite = CdCreateIrpContextLite( IrpContext );
    }
 
    //
    //  We want to clear the top level context in this thread if
    //  necessary.  Call our cleanup routine to do the work.
    //
 
    SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
    CdCleanupIrpContext( IrpContext, TRUE );
 
    //
    //  Synchronize with the CdData lock.
    //
 
    CdLockCdData();
 
    //
    //  If we have an IrpContext then put the request on the delayed close queue.
    //
 
    if (IrpContextLite != NULL) {
 
        //
        //  Initialize the IrpContextLite.
        //
 
        IrpContextLite->NodeTypeCode = CDFS_NTC_IRP_CONTEXT_LITE;
        IrpContextLite->NodeByteSize = sizeof( IRP_CONTEXT_LITE );
        IrpContextLite->Fcb = Fcb;
        IrpContextLite->UserReference = UserReference;
        IrpContextLite->RealDevice = IrpContext->RealDevice;
 
        //
        //  Add this to the delayed close list and increment
        //  the count.
        //
 
        InsertTailList( &CdData.DelayedCloseQueue,
                        &IrpContextLite->DelayedCloseLinks );
 
        CdData.DelayedCloseCount += 1;
 
        //
        //  If we are above our threshold then start the delayed
        //  close operation.
        //
 
        if (CdData.DelayedCloseCount > CdData.MaxDelayedCloseCount) {
 
            CdData.ReduceDelayedClose = TRUE;
 
            if (!CdData.FspCloseActive) {
 
                CdData.FspCloseActive = TRUE;
                StartWorker = TRUE;
            }
        }
 
        //
        //  Unlock the CdData.
        //
 
        CdUnlockCdData();
 
        //
        //  Cleanup the IrpContext.
        //
 
        CdCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
 
    //
    //  Otherwise drop into the async case below.
    //
 
    } else {
 
        //
        //  Store the information about the file object into the IrpContext.
        //
 
        IrpContext->Irp = (PIRP) Fcb;
        IrpContext->ExceptionStatus = (NTSTATUS) UserReference;
 
        //
        //  Add this to the async close list and increment the count.
        //
 
        InsertTailList( &CdData.AsyncCloseQueue,
                        &IrpContext->WorkQueueItem.List );
 
        CdData.AsyncCloseCount += 1;
 
        //
        //  Remember to start the Fsp close thread if not currently started.
        //
 
        if (!CdData.FspCloseActive) {
 
            CdData.FspCloseActive = TRUE;
 
            StartWorker = TRUE;
        }
 
        //
        //  Unlock the CdData.
        //
 
        CdUnlockCdData();
    }
 
    //
    //  Start the FspClose thread if we need to.
    //
 
    if (StartWorker) {
 
        IoQueueWorkItem( CdData.CloseItem, CdCloseWorker, CriticalWorkQueue, NULL );
    }
 
    //
    //  Return to our caller.
    //
 
    return;
}

CdRemoveClose()

PIRP_CONTEXT CdRemoveClose

(

_In_opt_ PVCB

Vcb

)

Definition at line 877 of file close.c.

{
    PIRP_CONTEXT IrpContext = NULL;
    PIRP_CONTEXT NextIrpContext;
    PIRP_CONTEXT_LITE NextIrpContextLite;
 
    PLIST_ENTRY Entry;
 
    PAGED_CODE();
 
    ASSERT_OPTIONAL_VCB( Vcb );
 
    //
    //  Lock the CdData to perform the scan.
    //
 
    CdLockCdData();
 
    //
    //  First check the list of async closes.
    //
 
    Entry = CdData.AsyncCloseQueue.Flink;
 
    while (Entry != &CdData.AsyncCloseQueue) {
 
        //
        //  Extract the IrpContext.
        //
 
        NextIrpContext = CONTAINING_RECORD( Entry,
                                            IRP_CONTEXT,
                                            WorkQueueItem.List );
 
        //
        //  If no Vcb was specified or this Vcb is for our volume
        //  then perform the close.
        //
 
        if (!ARGUMENT_PRESENT( Vcb ) || (NextIrpContext->Vcb == Vcb)) {
 
            RemoveEntryList( Entry );
            CdData.AsyncCloseCount -= 1;
 
            IrpContext = NextIrpContext;
            break;
        }
 
        //
        //  Move to the next entry.
        //
 
        Entry = Entry->Flink;
    }
 
    //
    //  If we didn't find anything look through the delayed close
    //  queue.
    //
    //  We will only check the delayed close queue if we were given
    //  a Vcb or the delayed close operation is active.
    //
 
    if ((IrpContext == NULL) &&
        (ARGUMENT_PRESENT( Vcb ) ||
         (CdData.ReduceDelayedClose &&
          (CdData.DelayedCloseCount > CdData.MinDelayedCloseCount)))) {
 
        Entry = CdData.DelayedCloseQueue.Flink;
 
        while (Entry != &CdData.DelayedCloseQueue) {
 
            //
            //  Extract the IrpContext.
            //
 
            NextIrpContextLite = CONTAINING_RECORD( Entry,
                                                    IRP_CONTEXT_LITE,
                                                    DelayedCloseLinks );
 
            //
            //  If no Vcb was specified or this Vcb is for our volume
            //  then perform the close.
            //
 
            if (!ARGUMENT_PRESENT( Vcb ) || (NextIrpContextLite->Fcb->Vcb == Vcb)) {
 
                RemoveEntryList( Entry );
                CdData.DelayedCloseCount -= 1;
 
                IrpContext = (PIRP_CONTEXT) NextIrpContextLite;
                break;
            }
 
            //
            //  Move to the next entry.
            //
 
            Entry = Entry->Flink;
        }
    }
 
    //
    //  If the Vcb wasn't specified and we couldn't find an entry
    //  then turn off the Fsp thread.
    //
 
    if (!ARGUMENT_PRESENT( Vcb ) && (IrpContext == NULL)) {
 
        CdData.FspCloseActive = FALSE;
        CdData.ReduceDelayedClose = FALSE;
    }
 
    //
    //  Unlock the CdData.
    //
 
    CdUnlockCdData();
 
    return IrpContext;
}