windows-server-2003/base/fs/ntfs/pnp.c

/*++

Copyright (c) 1991  Microsoft Corporation

Module Name:

    Pnp.c

Abstract:

    This module implements the Pnp routines for Ntfs called by the
    dispatch driver.

Author:

    Gary Kimura     [GaryKi]        29-Aug-1991

Revision History:

--*/

#include "NtfsProc.h"

//
//  The Bug check file id for this module
//

#define BugCheckFileId                   (NTFS_BUG_CHECK_PNP)

//
//  The local debug trace level
//

#define Dbg                              (DEBUG_TRACE_PNP)

//
//  Local procedure prototypes
//

NTSTATUS
NtfsCommonPnp (
    IN PIRP_CONTEXT IrpContext,
    IN PIRP *Irp,
    IN OUT PBOOLEAN CallerDecrementCloseCount
    );

NTSTATUS
NtfsPnpCompletionRoutine (
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PNTFS_COMPLETION_CONTEXT CompletionContext
    );

VOID
NtfsPerformSurpriseRemoval(
    IN PIRP_CONTEXT IrpContext,
    IN PVCB Vcb
    );

#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, NtfsCommonPnp)
#pragma alloc_text(PAGE, NtfsFsdPnp)
#pragma alloc_text(PAGE, NtfsPerformSurpriseRemoval)
#endif

NTSTATUS
NtfsFsdPnp (
    IN PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine implements the FSD entry point for plug and play (Pnp).

Arguments:

    VolumeDeviceObject - Supplies the volume device object where the
        file exists

    Irp - Supplies the Irp being processed

Return Value:

    NTSTATUS - The FSD status for the IRP

--*/

{
    NTSTATUS Status = STATUS_SUCCESS;

    TOP_LEVEL_CONTEXT TopLevelContext;
    PTOP_LEVEL_CONTEXT ThreadTopLevelContext;
    PIRP_CONTEXT IrpContext = NULL;
    BOOLEAN DecrementCloseCount = FALSE;

    ASSERT_IRP( Irp );

    UNREFERENCED_PARAMETER( VolumeDeviceObject );

#ifdef NTFSPNPDBG
    if (NtfsDebugTraceLevel != 0) SetFlag( NtfsDebugTraceLevel, DEBUG_TRACE_PNP );
#endif

    DebugTrace( +1, Dbg, ("NtfsFsdPnp\n") );

    //
    //  Call the common Pnp routine
    //

    FsRtlEnterFileSystem();

    switch( IoGetCurrentIrpStackLocation( Irp )->MinorFunction ) {

    case IRP_MN_QUERY_REMOVE_DEVICE:
    case IRP_MN_REMOVE_DEVICE:
    case IRP_MN_CANCEL_REMOVE_DEVICE:
    case IRP_MN_SURPRISE_REMOVAL:

        ThreadTopLevelContext = NtfsInitializeTopLevelIrp( &TopLevelContext, FALSE, FALSE );
        break;

    default:

        ThreadTopLevelContext = NtfsInitializeTopLevelIrp( &TopLevelContext, TRUE, TRUE );
        break;
    }

    do {

        try {

            //
            //  We are either initiating this request or retrying it.
            //

            if (NT_SUCCESS( Status ) &&
                (IrpContext == NULL)) {

                //
                //  Allocate and initialize the Irp.
                //

                NtfsInitializeIrpContext( Irp, TRUE, &IrpContext );

                //
                //  Initialize the thread top level structure, if needed.
                //

                NtfsUpdateIrpContextWithTopLevel( IrpContext, ThreadTopLevelContext );

            } else if (Status == STATUS_LOG_FILE_FULL) {

                NtfsCheckpointForLogFileFull( IrpContext );

            } else if (Status != STATUS_CANT_WAIT) {

                //
                // As long as Status is not STATUS_CANT_WAIT or STATUS_LOG_FILE_FULL,
                // we want to exit the loop.
                //

                if (DecrementCloseCount) {

                    NtfsAcquireExclusiveVcb( IrpContext, IrpContext->Vcb, TRUE );

                    IrpContext->Vcb->CloseCount -= 1;

                    NtfsReleaseVcbCheckDelete( IrpContext, IrpContext->Vcb, IrpContext->MajorFunction, NULL );

                    ClearFlag( IrpContext->State, IRP_CONTEXT_STATE_PERSISTENT );

                    NtfsCompleteRequest( IrpContext, NULL, Status );
                }

                break;
            }

            Status = NtfsCommonPnp( IrpContext, &Irp, &DecrementCloseCount );

        } except(NtfsExceptionFilter( IrpContext, 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
            //  execption code
            //

            Status = NtfsProcessException( IrpContext, Irp, GetExceptionCode() );
        }

    } while (TRUE);

    ASSERT( IoGetTopLevelIrp() != (PIRP) &TopLevelContext );
    FsRtlExitFileSystem();

    //
    //  And return to our caller
    //

    DebugTrace( -1, Dbg, ("NtfsFsdPnp -> %08lx\n", Status) );

    return Status;
}


NTSTATUS
NtfsCommonPnp (
    IN PIRP_CONTEXT IrpContext,
    IN PIRP *Irp,
    IN OUT PBOOLEAN CallerDecrementCloseCount
    )

/*++

Routine Description:

    This is the common routine for PnP called by the fsd thread.

Arguments:

    Irp - Supplies the Irp to process.  WARNING!  THIS IRP HAS NO
          FILE OBJECT IN OUR IRP STACK LOCATION!!!

    CallerDecrementCloseCount - Returns TRUE if the caller needs to decrement
                                the Vcb CloseCount.

Return Value:

    NTSTATUS - The return status for the operation

--*/

{
    NTSTATUS Status;
    NTSTATUS FlushStatus;
    PIO_STACK_LOCATION IrpSp;
    NTFS_COMPLETION_CONTEXT CompletionContext;
    PVOLUME_DEVICE_OBJECT OurDeviceObject;

    PVCB Vcb;
    BOOLEAN VcbAcquired = FALSE;
    BOOLEAN CheckpointAcquired = FALSE;

#ifdef SYSCACHE_DEBUG
    ULONG SystemHandleCount = 0;
#endif

    ASSERT_IRP_CONTEXT( IrpContext );
    ASSERT( FlagOn( IrpContext->TopLevelIrpContext->State, IRP_CONTEXT_STATE_OWNS_TOP_LEVEL ));

    if (*Irp != NULL) {

        ASSERT_IRP( *Irp );

        //
        //  Get the current Irp stack location.
        //

        IrpSp = IoGetCurrentIrpStackLocation( *Irp );

        //
        //  Find our Vcb.  This is tricky since we have no file object in the Irp.
        //

        OurDeviceObject = (PVOLUME_DEVICE_OBJECT) IrpSp->DeviceObject;

        //
        //  Make sure this device object really is big enough to be a volume device
        //  object.  If it isn't, we need to get out before we try to reference some
        //  field that takes us past the end of an ordinary device object.  Then we
        //  check if it is actually one of ours, just to be perfectly paranoid.
        //

        if (OurDeviceObject->DeviceObject.Size != sizeof(VOLUME_DEVICE_OBJECT) ||
            NodeType(&OurDeviceObject->Vcb) != NTFS_NTC_VCB) {

            NtfsCompleteRequest( IrpContext, *Irp, STATUS_INVALID_PARAMETER );
            return STATUS_INVALID_PARAMETER;
        }

        Vcb = &OurDeviceObject->Vcb;
        KeInitializeEvent( &CompletionContext.Event, NotificationEvent, FALSE );

    } else {

        Vcb = IrpContext->Vcb;
    }

    //
    //  Anyone who is flushing the volume or setting Vcb bits needs to get the
    //  vcb exclusively.
    //

    switch ( IrpContext->MinorFunction ) {

    case IRP_MN_QUERY_REMOVE_DEVICE:
    case IRP_MN_SURPRISE_REMOVAL:

        //
        //  Lock volume / dismount synchs with checkpoint - we need to do this first before
        //  acquiring the vcb to preserve locking order since we're going to do a lock in
        //  the query remove case and a dismount in the surprise removal
        //

        NtfsAcquireCheckpointSynchronization( IrpContext, Vcb );
        CheckpointAcquired = TRUE;

        // fall through

    case IRP_MN_REMOVE_DEVICE:
    case IRP_MN_CANCEL_REMOVE_DEVICE:

        NtfsAcquireExclusiveVcb( IrpContext, Vcb, TRUE );
        VcbAcquired = TRUE;
        break;
    }

    try {

        if (*Irp != NULL) {

            switch ( IrpContext->MinorFunction ) {

            case IRP_MN_QUERY_REMOVE_DEVICE:

                DebugTrace( 0, Dbg, ("IRP_MN_QUERY_REMOVE_DEVICE\n") );

                if (!FlagOn( Vcb->VcbState, VCB_STATE_VOLUME_MOUNTED )) {

                    Status = STATUS_VOLUME_DISMOUNTED;
                    break;
                }

                //
                //  If we already know we don't want to dismount this volume, don't bother
                //  flushing now.  If there's a nonzero cleanup count, flushing won't get
                //  the close count down to zero, so we might as well get out now.
                //

    #ifdef SYSCACHE_DEBUG
                if (Vcb->SyscacheScb != NULL) {
                    SystemHandleCount = Vcb->SyscacheScb->CleanupCount;
                }
                if ((Vcb->CleanupCount > SystemHandleCount) ||
    #else
                if ((Vcb->CleanupCount > 0) ||
    #endif
                    FlagOn(Vcb->VcbState, VCB_STATE_DISALLOW_DISMOUNT)) {

                    DebugTrace( 0, Dbg, ("IRP_MN_QUERY_REMOVE_DEVICE --> cleanup count still %x \n", Vcb->CleanupCount) );

                    //
                    //  We don't want the device to get removed or stopped if this volume has files
                    //  open.  We'll fail this query, and we won't bother calling the driver(s) below us.
                    //

                    Status = STATUS_UNSUCCESSFUL;

                } else {

                    //
                    //  We might dismount this volume soon, so let's try to flush and purge
                    //  everything we can right now.
                    //

                    FlushStatus = NtfsFlushVolume( IrpContext,
                                                   Vcb,
                                                   TRUE,
                                                   TRUE,
                                                   TRUE,
                                                   FALSE );

                    //
                    //  We need to make sure the cache manager is done with any lazy writes
                    //  that might be keeping the close count up.  Since Cc might need to
                    //  close some streams, we need to release the vcb.  We'd hate to have
                    //  the Vcb go away, so we'll bias the close count temporarily.
                    //

                    Vcb->CloseCount += 1;

                    NtfsReleaseVcb( IrpContext, Vcb );
                    CcWaitForCurrentLazyWriterActivity();

                    ASSERT( FlagOn( IrpContext->State, IRP_CONTEXT_STATE_WAIT ) );

                    NtfsAcquireExclusiveVcb( IrpContext, Vcb, TRUE );

                    Vcb->CloseCount -= 1;

                    //
                    //  Since we dropped the Vcb, we need to redo any tests we've done.
                    //

                    if (!FlagOn( Vcb->VcbState, VCB_STATE_VOLUME_MOUNTED )) {

                        Status = STATUS_VOLUME_DISMOUNTED;
                        break;
                    }


    #ifdef SYSCACHE_DEBUG
                    if (Vcb->SyscacheScb != NULL) {
                        SystemHandleCount = Vcb->SyscacheScb->CleanupCount;
                    }

                    if ((Vcb->CleanupCount > SystemHandleCount) ||
    #else
                    if ((Vcb->CleanupCount > 0) ||
    #endif
                        FlagOn(Vcb->VcbState, VCB_STATE_DISALLOW_DISMOUNT)) {

                        Status = STATUS_UNSUCCESSFUL;
                        break;
                    }

                    if ((Vcb->CloseCount - (Vcb->SystemFileCloseCount + Vcb->QueuedCloseCount)) > 0) {

                        DebugTrace( 0, Dbg, ("IRP_MN_QUERY_REMOVE_DEVICE --> %x user files still open \n", (Vcb->CloseCount - Vcb->SystemFileCloseCount)) );

                        //
                        //  We don't want the device to get removed or stopped if this volume has files
                        //  open.  We'll fail this query, and we won't bother calling the driver(s) below us.
                        //

                        Status = STATUS_UNSUCCESSFUL;

                    } else {

                        //
                        //  We've already done all we can to clear up any open files, so there's
                        //  no point in retrying if this lock volume fails.  We'll just tell
                        //  NtfsLockVolumeInternal we're already retrying.
                        //

                        ULONG Retrying = 1;

                        DebugTrace( 0, Dbg, ("IRP_MN_QUERY_REMOVE_DEVICE --> No user files, Locking volume \n") );

                        Status = NtfsLockVolumeInternal( IrpContext,
                                                         Vcb,
                                                         ((PFILE_OBJECT) 1),
                                                         &Retrying );

                        //
                        //  Remember not to send any irps to the target device now.
                        //

                        if (NT_SUCCESS( Status )) {

                            ASSERT_EXCLUSIVE_RESOURCE( &Vcb->Resource );
                            SetFlag( Vcb->VcbState, VCB_STATE_TARGET_DEVICE_STOPPED );
                        }
                    }
                }

                break;

            case IRP_MN_REMOVE_DEVICE:

                DebugTrace( 0, Dbg, ("IRP_MN_REMOVE_DEVICE\n") );

                //
                //  If remove_device is preceded by query_remove, we treat this just
                //  like a cancel_remove and unlock the volume and pass the irp to
                //  the driver(s) below the filesystem.
                //

                if (FlagOn( Vcb->VcbState, VCB_STATE_EXPLICIT_LOCK )) {

                    DebugTrace( 0, Dbg, ("IRP_MN_REMOVE_DEVICE --> Volume locked \n") );
                    Status = NtfsUnlockVolumeInternal( IrpContext, Vcb );

                } else {

                    //
                    //  The only other possibility is for remove_device to be prededed
                    //  by surprise_remove, in which case we treat this as a failed verify.
                    //

                    // **** TODO **** ADD CODE TO TREAT THIS LIKE A FAILED VERIFY

                    DebugTrace( 0, Dbg, ("IRP_MN_REMOVE_DEVICE --> Volume _not_ locked \n") );
                    Status = STATUS_SUCCESS;
                }

                break;

            case IRP_MN_SURPRISE_REMOVAL:

                DebugTrace( 0, Dbg, ("IRP_MN_SURPRISE_REMOVAL\n") );

                //
                //  For surprise removal, we call the driver(s) below us first, then do
                //  our processing. Let us also remember that we can't send any more
                //  IRPs to the target device.
                //

                SetFlag( Vcb->VcbState, VCB_STATE_TARGET_DEVICE_STOPPED );

                Status = STATUS_SUCCESS;
                break;

            case IRP_MN_CANCEL_REMOVE_DEVICE:

                Status = STATUS_SUCCESS;
                break;

            default:

                DebugTrace( 0, Dbg, ("Some other PnP IRP_MN_ %x\n", IrpContext->MinorFunction) );
                Status = STATUS_SUCCESS;
                break;
            }

            //
            //  We only pass this irp down if we didn't have some reason to fail it ourselves.
            //  We want to keep the IrpContext around for our own cleanup.
            //

            if (!NT_SUCCESS( Status )) {

                NtfsCompleteRequest( NULL, *Irp, Status );
                try_return( NOTHING );
            }

            //
            //  Get the next stack location, and copy over the stack location
            //

            IoCopyCurrentIrpStackLocationToNext( *Irp );

            //
            //  Set up the completion routine
            //

            CompletionContext.IrpContext = IrpContext;
            IoSetCompletionRoutine( *Irp,
                                    NtfsPnpCompletionRoutine,
                                    &CompletionContext,
                                    TRUE,
                                    TRUE,
                                    TRUE );

            //
            //  Send the request to the driver(s) below us. - We don't own it anymore
            //  so null it out
            //

            Status = IoCallDriver( Vcb->TargetDeviceObject, *Irp );
            *Irp = IrpContext->OriginatingIrp = NULL;

            //
            //   Wait for the driver to definitely complete
            //

            if (Status == STATUS_PENDING) {

                KeWaitForSingleObject( &CompletionContext.Event,
                                       Executive,
                                       KernelMode,
                                       FALSE,
                                       NULL );
                KeClearEvent( &CompletionContext.Event );
            }
        }

        //
        //  Post processing - these are items that need to be done after the lower
        //  storage stack has processed the request.
        //

        switch (IrpContext->MinorFunction) {

        case IRP_MN_SURPRISE_REMOVAL:

            //
            //  Start the tear-down process irrespective of the status
            //  the driver below us sent back. There's no turning back here.
            //

            if (FlagOn( Vcb->VcbState, VCB_STATE_VOLUME_MOUNTED )) {

                if (!*CallerDecrementCloseCount) {

                    SetFlag( IrpContext->State, IRP_CONTEXT_STATE_PERSISTENT );
                    Vcb->CloseCount += 1;
                    *CallerDecrementCloseCount = TRUE;
                }

                NtfsPerformSurpriseRemoval( IrpContext, Vcb );
            }
            break;

        case IRP_MN_CANCEL_REMOVE_DEVICE:

            //
            //  Since we cancelled and have told the driver we can now safely unlock
            //  the volume and send ioctls to the drive (unlock media)
            //

            ClearFlag( Vcb->VcbState, VCB_STATE_TARGET_DEVICE_STOPPED );

            if (FlagOn( Vcb->VcbState, VCB_STATE_EXPLICIT_LOCK )) {

                if (!*CallerDecrementCloseCount) {

                    SetFlag( IrpContext->State, IRP_CONTEXT_STATE_PERSISTENT );
                    Vcb->CloseCount += 1;
                    *CallerDecrementCloseCount = TRUE;
                }

                DebugTrace( 0, Dbg, ("IRP_MN_CANCEL_REMOVE_DEVICE --> Volume locked \n") );
                NtfsUnlockVolumeInternal( IrpContext, Vcb );

            }
            break;
        }

    try_exit: NOTHING;
    } finally {

        if (VcbAcquired) {

            //
            //  All 4 paths query / remove / surprise remove / cancel remove
            //  come through here. For the 3 except query we want the vcb to go away
            //  if possible. In the query remove path - dismount won't be complete
            //  even if the close count is 0 (since the dismount is incomplete)
            //  so this will only release
            //

            NtfsReleaseVcbCheckDelete( IrpContext, Vcb, IrpContext->MajorFunction, NULL );
        }

        if (CheckpointAcquired) {
            NtfsReleaseCheckpointSynchronization( IrpContext, Vcb );
        }
    }

    //
    //  Cleanup our IrpContext;  The underlying driver completed the Irp.
    //

    DebugTrace( -1, Dbg, ("NtfsCommonPnp -> %08lx\n", Status ) );
    NtfsCompleteRequest( IrpContext, NULL, Status );
    return Status;
}


//
//  Local support routine
//

NTSTATUS
NtfsPnpCompletionRoutine (
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PNTFS_COMPLETION_CONTEXT CompletionContext
    )
{
    PIO_STACK_LOCATION IrpSp;
    PIRP_CONTEXT IrpContext;
    PVOLUME_DEVICE_OBJECT OurDeviceObject;

    PVCB Vcb;
    BOOLEAN VcbAcquired = FALSE;

    ASSERT_IRP( Irp );

    IrpContext = CompletionContext->IrpContext;
    ASSERT_IRP_CONTEXT( IrpContext );

    //
    //  Get the current Irp stack location.
    //

    IrpSp = IoGetCurrentIrpStackLocation( Irp );

    //
    //  Find our Vcb.  This is tricky since we have no file object in the Irp.
    //

    OurDeviceObject = (PVOLUME_DEVICE_OBJECT) DeviceObject;

    //
    //  Make sure this device object really is big enough to be a volume device
    //  object.  If it isn't, we need to get out before we try to reference some
    //  field that takes us past the end of an ordinary device object.  Then we
    //  check if it is actually one of ours, just to be perfectly paranoid.
    //

    if (OurDeviceObject->DeviceObject.Size != sizeof(VOLUME_DEVICE_OBJECT) ||
        NodeType(&OurDeviceObject->Vcb) != NTFS_NTC_VCB) {

        return STATUS_INVALID_PARAMETER;
    }

    Vcb = &OurDeviceObject->Vcb;

    KeSetEvent( &CompletionContext->Event, 0, FALSE );

    //
    //  Propagate the Irp pending state.
    //

    if (Irp->PendingReturned) {

        IoMarkIrpPending( Irp );
    }

    return STATUS_SUCCESS;
}

//
// Local utility routine
//


VOID
NtfsPerformSurpriseRemoval (
    IN PIRP_CONTEXT IrpContext,
    IN PVCB Vcb
    )

/*++

    Performs further processing on SURPRISE_REMOVAL notifications.

--*/

{
    ASSERT(ExIsResourceAcquiredExclusiveLite( &Vcb->Resource ));

    //
    //  Flush and purge and mark all files as dismounted.
    //  Since there may be outstanding handles, we could still see any
    //  operation (read, write, set info, etc.) happen for files on the
    //  volume after surprise_remove.  Since all the files will be marked
    //  for dismount, we will fail these operations gracefully.  All
    //  operations besides cleanup & close on the volume will fail from
    //  this time on.
    //

    if (!FlagOn( Vcb->VcbState, VCB_STATE_DISALLOW_DISMOUNT )) {

        (VOID)NtfsFlushVolume( IrpContext,
                               Vcb,
                               FALSE,
                               TRUE,
                               TRUE,
                               TRUE );

        NtfsPerformDismountOnVcb( IrpContext, Vcb, TRUE, NULL );
    }

    return;
}