windows-xp/Source/XPSP1/NT/base/fs/rdr2/rdbss/obsolete/verfysup.c

/*++

Copyright (c) 1989  Microsoft Corporation

Module Name:

    VerfySup.c

Abstract:

    This module implements the Rx Verify volume and fcb/dcb support
    routines

Author:

    Gary Kimura     [GaryKi]    01-Jun-1990

Revision History:

--*/

//    ----------------------joejoe-----------found-------------#include "RxProcs.h"
#include "precomp.h"
#pragma hdrstop

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

#define BugCheckFileId                   (RDBSS_BUG_CHECK_VERFYSUP)

//
//  The Debug trace level for this module
//

#define Dbg                              (DEBUG_TRACE_VERFYSUP)

//
//  Local procedure prototypes
//

VOID
RxResetFcb (
    IN PRX_CONTEXT RxContext,
    IN PFCB Fcb
    );

VOID
RxDetermineAndMarkFcbCondition (
    IN PRX_CONTEXT RxContext,
    IN PFCB Fcb
    );

VOID
RxDeferredCleanVolume (
    PVOID Parameter
    );

RXSTATUS
RxMarkDirtyCompletionRoutine(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Contxt
    );

#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, RxCheckDirtyBit)
#pragma alloc_text(PAGE, RxVerifyOperationIsLegal)
#pragma alloc_text(PAGE, RxDeferredCleanVolume)
#pragma alloc_text(PAGE, RxDetermineAndMarkFcbCondition)
#pragma alloc_text(PAGE, RxQuickVerifyVcb)
#pragma alloc_text(PAGE, RxPerformVerify)
#pragma alloc_text(PAGE, RxMarkFcbCondition)
#pragma alloc_text(PAGE, RxMarkVolumeClean)
#pragma alloc_text(PAGE, RxResetFcb)
#pragma alloc_text(PAGE, RxVerifyVcb)
#pragma alloc_text(PAGE, RxVerifyFcb)
#endif


VOID
RxMarkFcbCondition (
    IN PRX_CONTEXT RxContext,
    IN PFCB Fcb,
    IN FCB_CONDITION FcbCondition
    )

/*++

Routine Description:

    This routines marks the entire Fcb/Dcb structure from Fcb down with
    FcbCondition.

Arguments:

    Fcb - Supplies the Fcb/Dcb being marked

    FcbCondition - Supplies the setting to use for the Fcb Condition

Return Value:

    None.

--*/

{
    DebugTrace(+1, Dbg, "RxMarkFcbCondition, Fcb = %08lx\n", Fcb );

    //
    //  If we are marking this Fcb something other than Good, we will need
    //  to have the Vcb exclusive.

    ASSERT( FcbCondition != FcbNeedsToBeVerified ? TRUE :
            RxVcbAcquiredExclusive(RxContext, Fcb->Vcb) );

    //
    //  If this is a PagingFile it has to be good.
    //

    if (FlagOn(Fcb->FcbState, FCB_STATE_PAGING_FILE)) {

        Fcb->FcbCondition = FcbGood;
        return;
    }

    //
    //  Update the condition of the Fcb.
    //

    Fcb->FcbCondition = FcbCondition;

    DebugTrace(0, Dbg, "MarkFcb: %wZ\n", &Fcb->FullFileName);

    //
    //  This FastIo flag is based on FcbCondition, so update it now.
    //

    Fcb->Header.IsFastIoPossible = RxIsFastIoPossible( Fcb );

    //
    //  Now if we marked NeedsVerify or Bad a directory then we also need to
    //  go and mark all of our children with the same condition.
    //

    if ( ((FcbCondition == FcbNeedsToBeVerified) ||
          (FcbCondition == FcbBad)) &&
         ((Fcb->Header.NodeTypeCode == RDBSS_NTC_DCB) ||
          (Fcb->Header.NodeTypeCode == RDBSS_NTC_ROOT_DCB)) ) {

        PFCB OriginalFcb = Fcb;

        while ( (Fcb = RxGetNextFcb(RxContext, Fcb, OriginalFcb)) != NULL ) {

            DebugTrace(0, Dbg, "MarkFcb: %wZ\n", &Fcb->FullFileName);

            Fcb->FcbCondition = FcbCondition;

            Fcb->Header.IsFastIoPossible = RxIsFastIoPossible( Fcb );
        }
    }

    DebugTrace(-1, Dbg, "RxMarkFcbCondition -> VOID\n", 0);

    return;
}


VOID
RxVerifyVcb (
    IN PRX_CONTEXT RxContext,
    IN PVCB Vcb
    )

/*++

Routine Description:

    This routines verifies that the Vcb still denotes a valid Volume
    If the Vcb is bad it raises an error condition.

Arguments:

    Vcb - Supplies the Vcb being verified

Return Value:

    None.

--*/

{
    DebugTrace(+1, Dbg, "RxVerifyVcb, Vcb = %08lx\n", Vcb );

    //
    //  If the media is removable and the verify volume flag in the
    //  device object is not set then we want to ping the device
    //  to see if it needs to be verified.
    //
    //  Note that we only force this ping for create operations.
    //  For others we take a sporting chance.  If in the end we
    //  have to physically access the disk, the right thing will happen.
    //

    if ( FlagOn(Vcb->VcbState, VCB_STATE_FLAG_REMOVABLE_MEDIA) &&
         !FlagOn(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME) ) {

        PIRP Irp;
        KEVENT Event;
        IO_STATUS_BLOCK Iosb;
        RXSTATUS Status;

        KeInitializeEvent( &Event, NotificationEvent, FALSE );

        Irp = IoBuildDeviceIoControlRequest( IOCTL_DISK_CHECK_VERIFY,
                                             Vcb->TargetDeviceObject,
                                             NULL,
                                             0,
                                             NULL,
                                             0,
                                             FALSE,
                                             &Event,
                                             &Iosb );

        if ( Irp == NULL ) {

            RxRaiseStatus( RxContext, RxStatus(INSUFFICIENT_RESOURCES) );
        }

        Status = IoCallDriver( Vcb->TargetDeviceObject, Irp );


        if (Status == RxStatus(PENDING)) {
            Status = KeWaitForSingleObject( &Event,
                                            Executive,
                                            KernelMode,
                                            FALSE,
                                            NULL );

            ASSERT( Status == RxStatus(SUCCESS) );

            //
            //  This may raise an error.
            //

            if ( !NT_SUCCESS(Iosb.Status) ) {

                RxNormalizeAndRaiseStatus( RxContext, Iosb.Status );
            }

        } else {

            //
            //  This may raise an error.
            //

            if ( !NT_SUCCESS(Status) ) {

                RxNormalizeAndRaiseStatus( RxContext, Status );
            }
        }
    }

    //
    //  Now that the verify bit has been appropriately set, check the Vcb.
    //

    RxQuickVerifyVcb( RxContext, Vcb );

    DebugTrace(-1, Dbg, "RxVerifyVcb -> VOID\n", 0);

    return;
}


VOID
RxVerifyFcb (
    IN PRX_CONTEXT RxContext,
    IN PFCB Fcb
    )

/*++

Routine Description:

    This routines verifies that the Fcb still denotes the same file.
    If the Fcb is bad it raises a error condition.

Arguments:

    Fcb - Supplies the Fcb being verified

Return Value:

    None.

--*/

{
    PFCB CurrentFcb;

    DebugTrace(+1, Dbg, "RxVerifyFcb, Vcb = %08lx\n", Fcb );

    //
    //  If this is the Fcb of a deleted dirent or our parent is deleted,
    //  no-op this call with the hope that the caller will do the right thing.
    //

    if (IsFileDeleted( RxContext, Fcb ) ||
        ((NodeType(Fcb) != RDBSS_NTC_ROOT_DCB) &&
         IsFileDeleted( RxContext, Fcb->ParentDcb ))) {

        return;
    }

    //
    //  If we are not in the process of doing a verify,
    //  first do a quick spot check on the Vcb.
    //

    if ( Fcb->Vcb->VerifyThread != KeGetCurrentThread() ) {

        RxQuickVerifyVcb( RxContext, Fcb->Vcb );
    }

    //
    //  Now based on the condition of the Fcb we'll either return
    //  immediately to the caller, raise a condition, or do some work
    //  to verify the Fcb.
    //

    switch (Fcb->FcbCondition) {

    case FcbGood:

        DebugTrace(0, Dbg, "The Fcb is good\n", 0);
        break;

    case FcbBad:

        RxRaiseStatus( RxContext, RxStatus(FILE_INVALID) );
        break;

    case FcbNeedsToBeVerified:

        //
        //  We loop here checking our ancestors until we hit an Fcb which
        //  is either good or bad.
        //

        CurrentFcb = Fcb;

        while (CurrentFcb->FcbCondition == FcbNeedsToBeVerified) {

            RxDetermineAndMarkFcbCondition(RxContext, CurrentFcb);

            //
            //  If this Fcb didn't make it, or it was the Root Dcb, exit
            //  the loop now, else continue with out parent.
            //

            if ( (CurrentFcb->FcbCondition != FcbGood) ||
                 (NodeType(CurrentFcb) == RDBSS_NTC_ROOT_DCB) ) {

                break;
            }

            CurrentFcb = CurrentFcb->ParentDcb;
        }

        //
        //  Now we can just look at ourselves to see how we did.
        //

        if (Fcb->FcbCondition != FcbGood) {

            RxRaiseStatus( RxContext, RxStatus(FILE_INVALID) );
        }

        break;

    default:

        DebugDump("Invalid FcbCondition\n", 0, Fcb);
        RxBugCheck( Fcb->FcbCondition, 0, 0 );
    }

    DebugTrace(-1, Dbg, "RxVerifyFcb -> VOID\n", 0);

    return;
}

VOID
RxDeferredCleanVolume (
    PVOID Parameter
    )

/*++

Routine Description:

    This is the routine that performs the actual RxMarkVolumeClean call.
    It assures that the target volume still exists as there ia a race
    condition between queueing the ExWorker item and volumes going away.

Arguments:

    Parameter - Points to a clean volume packet that was allocated from pool

Return Value:

    None.

--*/

{
    PCLEAN_AND_DIRTY_VOLUME_PACKET Packet;
    PLIST_ENTRY Links;
    PVCB Vcb;
    RX_CONTEXT RxContext;
    BOOLEAN VcbExists = FALSE;

    DebugTrace(+1, Dbg, "RxDeferredCleanVolume\n", 0);

    Packet = (PCLEAN_AND_DIRTY_VOLUME_PACKET)Parameter;

    Vcb = Packet->Vcb;

    //
    //  Make us appear as a top level FSP request so that we will
    //  receive any errors from the operation.
    //

    IoSetTopLevelIrp( (PIRP)FSRTL_FSP_TOP_LEVEL_IRP );

    //
    //  Dummy up and Irp Context so we can call our worker routines
    //

    RtlZeroMemory( &RxContext, sizeof(RX_CONTEXT));

    SetFlag(RxContext.Flags, RX_CONTEXT_FLAG_WAIT);

    //
    //  Acquire shared access to the global lock and make sure this volume
    //  still exists.
    //

    RxAcquireSharedGlobal( &RxContext );

    for (Links = RxData.VcbQueue.Flink;
         Links != &RxData.VcbQueue;
         Links = Links->Flink) {

        PVCB ExistingVcb;

        ExistingVcb = CONTAINING_RECORD(Links, VCB, VcbLinks);

        if ( Vcb == ExistingVcb ) {

            VcbExists = TRUE;
            break;
        }
    }

    //
    //  If the vcb is good then mark it clean.  Ignore any problems.
    //

    if ( VcbExists &&
         (Vcb->VcbCondition == VcbGood) ) {

        try {

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

                RxMarkVolumeClean( &RxContext, Vcb );
            }

            //
            //  Check for a pathelogical race condition, and fix it.
            //

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

                RxMarkVolumeDirty( &RxContext, Vcb, FALSE );

            } else {

                //
                //  Unlock the volume if it is removable.
                //

                if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_REMOVABLE_MEDIA) &&
                    !FlagOn(Vcb->VcbState, VCB_STATE_FLAG_BOOT_OR_PAGING_FILE)) {

                    RxToggleMediaEjectDisable( &RxContext, Vcb, FALSE );
                }
            }

        } except( FsRtlIsNtstatusExpected(GetExceptionCode()) ?
                  EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) {

            NOTHING;
        }
    }

    //
    //  Release the global resource, unpin and repinned Bcbs and return.
    //

    RxReleaseGlobal( &RxContext );

    try {

        RxUnpinRepinnedBcbs( &RxContext );

    } except( FsRtlIsNtstatusExpected(GetExceptionCode()) ?
              EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) {

        NOTHING;
    }

    IoSetTopLevelIrp( NULL );

    //
    //  and finally free the packet.
    //

    ExFreePool( Packet );

    return;
}


VOID
RxCleanVolumeDpc (
    IN PKDPC Dpc,
    IN PVOID DeferredContext,
    IN PVOID SystemArgument1,
    IN PVOID SystemArgument2
    )

/*++

Routine Description:

    This routine is dispatched 5 seconds after the last disk structure was
    modified in a specific volume, and exqueues an execuative worker thread
    to perform the actual task of marking the volume dirty.

Arguments:

    DefferedContext - Contains the Vcb to process.

Return Value:

    None.

--*/

{
    PVCB Vcb;
    PCLEAN_AND_DIRTY_VOLUME_PACKET Packet;

    Vcb = (PVCB)DeferredContext;

    //
    //  If there is still dirty data (highly unlikely), set the timer for a
    //  second in the future.
    //

    if (CcIsThereDirtyData(Vcb->Vpb)) {

        LARGE_INTEGER TwoSecondsFromNow;

        TwoSecondsFromNow.QuadPart = -2*1000*1000*10;

        KeSetTimer( &Vcb->CleanVolumeTimer,
                    TwoSecondsFromNow,
                    &Vcb->CleanVolumeDpc );

        return;
    }

    //
    //  If we couldn't get pool, oh well....
    //

    Packet = ExAllocatePool(NonPagedPool, sizeof(CLEAN_AND_DIRTY_VOLUME_PACKET));

    if ( Packet ) {

        Packet->Vcb = Vcb;
        Packet->Irp = NULL;

        //
        //  Clear the dirty flag now since we cannot synchronize after this point.
        //

        ClearFlag( Packet->Vcb->VcbState, VCB_STATE_FLAG_VOLUME_DIRTY );

        ExInitializeWorkItem( &Packet->Item, &RxDeferredCleanVolume, Packet );

        ExQueueWorkItem( &Packet->Item, CriticalWorkQueue );
    }

    return;
}


VOID
RxMarkVolumeClean (
    IN PRX_CONTEXT RxContext,
    IN PVCB Vcb
    )

/*++

Routine Description:

    This routine marks the indicated rx volume as clean, but only if it is
    a non-removable media.  The volume is marked dirty by setting the first
    reserved byte of the first dirent in the root directory to 0.

Arguments:

    Vcb - Supplies the Vcb being modified

Return Value:

    None.

--*/

{
    PDIRENT Dirent;
    PBCB DirentBcb = NULL;
    RXSTATUS Status;

    DebugTrace(+1, Dbg, "RxMarkVolumeClean, Vcb = %08lx\n", Vcb);

    DebugTrace(0, Dbg, "Mark volume clean\n", 0);

    DirentBcb = NULL;

    //
    //  Make Wait TRUE
    //

    SetFlag( RxContext->Flags, RX_CONTEXT_FLAG_WAIT );

    RxAcquireSharedFcb( RxContext, Vcb->RootDcb );

    try {

        //
        //  Bail if we get an IO error.
        //

        try {

            RxReadDirectoryFile( RxContext,
                                  Vcb->RootDcb,
                                  0,
                                  sizeof(DIRENT),
                                  TRUE,
                                  &DirentBcb,
                                  (PVOID *)&Dirent,
                                  &Status );

            //
            //  Set the volume clean.
            //

            ClearFlag( Dirent->NtByte, RDBSS_DIRENT_NT_BYTE_DIRTY );

            //
            //  Set the Bcb dirty and conditionally flush it.
            //

            CcSetDirtyPinnedData( DirentBcb, NULL );

        } except( RxExceptionFilter( RxContext, GetExceptionInformation() ) ) {

            NOTHING;
        }

        if (DirentBcb) {

            RxUnpinBcb( RxContext, DirentBcb );

            //
            //  Always flush this so that the drive is not unlocked prematurely
            //

            CcFlushCache( &Vcb->RootDcb->NonPaged->SectionObjectPointers,
                          &RxLargeZero,
                          sizeof( DIRENT ),
                          NULL );
        }

    } finally {

        RxReleaseFcb( RxContext, Vcb->RootDcb );
    }

    DebugTrace(-1, Dbg, "RxMarkVolumeClean -> VOID\n", 0);

    return;
}


VOID
RxFspMarkVolumeDirtyWithRecover(
    PVOID Parameter
    )

/*++

Routine Description:

    This is the routine that performs the actual RxMarkVolumeDirty call
    on of paging file Io that encounters a media error.  It is responsible
    for completing the PagingIo Irp as soon as this is done.

    Note:  this routine (and thus RxMarkVolumeDirty() must be resident as
           the paging file might be damaged at this point.

Arguments:

    Parameter - Points to a dirty volume packet that was allocated from pool

Return Value:

    None.

--*/

{
    PCLEAN_AND_DIRTY_VOLUME_PACKET Packet;
    PVCB Vcb;
    RX_CONTEXT RxContext;
    PIRP Irp;
    BOOLEAN VcbExists = FALSE;

    DebugTrace(+1, Dbg, "RxDeferredCleanVolume\n", 0);

    Packet = (PCLEAN_AND_DIRTY_VOLUME_PACKET)Parameter;

    Vcb = Packet->Vcb;
    Irp = Packet->Irp;

    //
    //  Dummy up the RxContext so we can call our worker routines
    //

    RtlZeroMemory( &RxContext, sizeof(RX_CONTEXT));

    SetFlag(RxContext.Flags, RX_CONTEXT_FLAG_WAIT);
    RxContext.CurrentIrp = Irp;

    //
    //  Make us appear as a top level FSP request so that we will
    //  receive any errors from the operation.
    //

    IoSetTopLevelIrp( (PIRP)FSRTL_FSP_TOP_LEVEL_IRP );

    //
    //  Try to write out the dirty bit.  If something goes wrong, we
    //  tried.
    //

    try {

        SetFlag( Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY );

        RxMarkVolumeDirty( &RxContext, Vcb, TRUE );

    } except(RxExceptionFilter( &RxContext, GetExceptionInformation() )) {

        NOTHING;
    }

    IoSetTopLevelIrp( NULL );

    //
    //  Now complete the originating Irp
    //

    IoCompleteRequest( Irp, IO_DISK_INCREMENT );
}


VOID
RxMarkVolumeDirty (
    IN PRX_CONTEXT RxContext,
    IN PVCB Vcb,
    IN BOOLEAN PerformSurfaceTest
    )

/*++

Routine Description:

    This routine marks the indicated rx volume as dirty, but only if it is
    a non-removable media.  The volume is marked dirty by setting the first
    reserved byte of the first dirent in the root directory to 1.

Arguments:

    Vcb - Supplies the Vcb being modified

    PerformSurfaceTest - Indicates to autochk that we think the media may be
        defective and that a surface test should be performed.

Return Value:

    None.

--*/

{
    PDIRENT Dirent;
    PBCB DirentBcb;
    KEVENT Event;
    PIRP Irp;
    LARGE_INTEGER ByteOffset;
    RXSTATUS Status;
    BOOLEAN ReleaseFcb = FALSE;

    DebugTrace(+1, Dbg, "RxMarkVolumeDirty, Vcb = %08lx\n", Vcb);

    Irp = NULL;
    DirentBcb = NULL;

    //
    //  Bail if we get an IO error.
    //

    try {

        //
        //  Make Wait TRUE
        //

        SetFlag( RxContext->Flags, RX_CONTEXT_FLAG_WAIT );

        ReleaseFcb = RxAcquireSharedFcb( RxContext, Vcb->RootDcb );

        //
        //  Call Cc directly here so that RxReadDirectoryFile doesn't
        //  have to be resident.
        //

        CcPinRead( Vcb->RootDcb->Specific.Dcb.DirectoryFile,
                   &RxLargeZero,
                   sizeof(DIRENT),
                   TRUE,
                   &DirentBcb,
                   (PVOID *)&Dirent );

        DbgDoit( RxContext->PinCount += 1 )

        //
        //  Set the volume dirty.
        //

        SetFlag( Dirent->NtByte, RDBSS_DIRENT_NT_BYTE_DIRTY );

        //
        //  In addition, if this request received an error that may indicate
        //  media corruption, have autochk perform a surface test.
        //

        if ( PerformSurfaceTest ) {

            SetFlag( Dirent->NtByte, RDBSS_DIRENT_NT_BYTE_TEST_SURFACE );
        }

        //
        //  Initialize the event we're going to use
        //

        KeInitializeEvent( &Event, NotificationEvent, FALSE );

        //
        //  Build the irp for the operation and also set the overrride flag.
        //  Note that we may be at APC level, so do this asyncrhonously and
        //  use an event for synchronization as normal request completion
        //  cannot occur at APC level.
        //

        ByteOffset.QuadPart = Vcb->AllocationSupport.RootDirectoryLbo;

        Irp = IoBuildAsynchronousFsdRequest( IRP_MJ_WRITE,
                                             Vcb->TargetDeviceObject,
                                             (PVOID)Dirent,
                                             1 << Vcb->AllocationSupport.LogOfBytesPerSector,
                                             &ByteOffset,
                                             NULL );

        if ( Irp == NULL ) {

            RxRaiseStatus( RxContext, RxStatus(INSUFFICIENT_RESOURCES) );
        }

        //
        //  Set up the completion routine
        //

        IoSetCompletionRoutine( Irp,
                                RxMarkDirtyCompletionRoutine,
                                &Event,
                                TRUE,
                                TRUE,
                                TRUE );

        //
        //  Call the device to do the write and wait for it to finish.
        //

        (VOID)IoCallDriver( Vcb->TargetDeviceObject, Irp );
        (VOID)KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, (PLARGE_INTEGER)NULL );

        //
        //  Grab the Status.
        //

        Status = Irp->IoStatus.Status;

        //
        //  Raise any error status
        //

        if (!NT_SUCCESS(Status)) {

            RxNormalizeAndRaiseStatus( RxContext, Status );
        }

    } finally {

        //
        //  Clean up the Irp and Mdl
        //

        if (Irp) {

            //
            //  If there is an MDL (or MDLs) associated with this I/O
            //  request, Free it (them) here.  This is accomplished by
            //  walking the MDL list hanging off of the IRP and deallocating
            //  each MDL encountered.
            //

            while (Irp->MdlAddress != NULL) {

                PMDL NextMdl;

                NextMdl = Irp->MdlAddress->Next;

                MmUnlockPages( Irp->MdlAddress );

                IoFreeMdl( Irp->MdlAddress );

                Irp->MdlAddress = NextMdl;
            }

            IoFreeIrp( Irp );
        }

        if (DirentBcb != NULL) {

            RxUnpinBcb( RxContext, DirentBcb );
        }

        if (ReleaseFcb) {

            RxReleaseFcb( RxContext, Vcb->RootDcb );
        }
    }

    DebugTrace(-1, Dbg, "RxMarkVolumeDirty -> VOID\n", 0);

    return;
}


VOID
RxCheckDirtyBit (
    IN PRX_CONTEXT RxContext,
    IN PVCB Vcb
    )

/*++

Routine Description:

    This routine looks at the volume dirty bit, and depending on the state of
    VCB_STATE_FLAG_MOUNTED_DIRTY, the appropriate action is taken.

Arguments:

    Vcb - Supplies the Vcb being queried.

Return Value:

    None.

--*/

{
    BOOLEAN Dirty;

    PDIRENT Dirent;
    PBCB DirtyBitBcb;

    RXSTATUS Status;

    UNICODE_STRING VolumeLabel;

    //
    //  Look in the first dirent
    //

    RxReadDirectoryFile( RxContext,
                          Vcb->RootDcb,
                          0,
                          sizeof(DIRENT),
                          FALSE,
                          &DirtyBitBcb,
                          (PVOID *)&Dirent,
                          &Status );

    ASSERT( NT_SUCCESS( Status ));

    //
    //  Check if the magic bit is set
    //

    Dirty = BooleanFlagOn( Dirent->NtByte, RDBSS_DIRENT_NT_BYTE_DIRTY );

    //
    //  Setup the VolumeLabel string
    //

    VolumeLabel.Length = Vcb->Vpb->VolumeLabelLength;
    VolumeLabel.MaximumLength = MAXIMUM_VOLUME_LABEL_LENGTH;
    VolumeLabel.Buffer = &Vcb->Vpb->VolumeLabel[0];

    if ( Dirty ) {

        KdPrint(("FASTRDBSS: WARNING! Mounting Dirty Volume %wZ\n", &VolumeLabel));

        SetFlag( Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY );

    } else {

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

            KdPrint(("FASTRDBSS: Volume %wZ has been cleaned.\n", &VolumeLabel));

            ClearFlag( Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY );

        } else {

            (VOID)FsRtlBalanceReads( Vcb->TargetDeviceObject );
        }
    }

    RxUnpinBcb( RxContext, DirtyBitBcb );
}


VOID
RxVerifyOperationIsLegal ( RXCOMMON_SIGNATURE )

/*++

Routine Description:

    This routine determines is the requested operation should be allowed to
    continue.  It either returns to the user if the request is Okay, or
    raises an appropriate status.

Arguments:

    Irp - Supplies the Irp to check

Return Value:

    None.

--*/

{
    RxCaptureRequestPacket;
    RxCaptureParamBlock; RxCaptureFileObject;

    //
    //  If the Irp is not present, then we got here via close.
    //
    //

    if ( capReqPacket == NULL ) {

        return;
    }

    //
    //  If there is not a file object, we cannot continue.
    //

    if ( capFileObject == NULL ) {

        return;
    }

    //
    //  If we are trying to do any other operation than close on a file
    //  object marked for delete, raise RxStatus(DELETE_PENDING).
    //

    if ( ( capFileObject->DeletePending == TRUE ) &&
         ( RxContext->MajorFunction != IRP_MJ_CLEANUP ) &&
         ( RxContext->MajorFunction != IRP_MJ_CLOSE ) ) {

        RxRaiseStatus( RxContext, RxStatus(DELETE_PENDING) );
    }

    //
    //  If we are doing a create, and there is a related file objects, and
    //  it it is marked for delete, raise RxStatus(DELETE_PENDING).
    //

    if ( RxContext->MajorFunction == IRP_MJ_CREATE ) {

        PFILE_OBJECT RelatedFileObject;

        RelatedFileObject = capFileObject->RelatedFileObject;

        if ( (RelatedFileObject != NULL) &&
             FlagOn(((PFCB)RelatedFileObject->FsContext)->FcbState,
                    FCB_STATE_DELETE_ON_CLOSE) )  {

            RxRaiseStatus( RxContext, RxStatus(DELETE_PENDING) );
        }
    }

    //
    //  If the file object has already been cleaned up, and
    //
    //  A) This request is a paging io read or write, or
    //  B) This request is a close operation, or
    //  C) This request is a set or query info call (for Lou)
    //  D) This is an MDL complete
    //
    //  let it pass, otherwise return RxStatus(FILE_CLOSED).
    //

    if ( FlagOn(capFileObject->Flags, FO_CLEANUP_COMPLETE) ) {

        if ( (FlagOn(capReqPacket->Flags, IRP_PAGING_IO)) ||
             (capPARAMS->MajorFunction == IRP_MJ_CLOSE ) ||
             (capPARAMS->MajorFunction == IRP_MJ_SET_INFORMATION) ||
             (capPARAMS->MajorFunction == IRP_MJ_QUERY_INFORMATION) ||
             ( ( (capPARAMS->MajorFunction == IRP_MJ_READ) ||
                 (capPARAMS->MajorFunction == IRP_MJ_WRITE) ) &&
               FlagOn(capPARAMS->MinorFunction, IRP_MN_COMPLETE) ) ) {

            NOTHING;

        } else {

            RxRaiseStatus( RxContext, RxStatus(FILE_CLOSED) );
        }
    }

    return;
}



//
//  Internal support routine
//

VOID
RxResetFcb (
    IN PRX_CONTEXT RxContext,
    IN PFCB Fcb
    )

/*++

Routine Description:

    This routine is called when an Fcb has been marked as needs to be verified.

    It does the following tasks:

        - Reset Mcb mapping information
        - For directories, reset dirent hints
        - Set allocation size to unknown

Arguments:

    Fcb - Supplies the Fcb to reset

Return Value:

    None.

--*/

{
    //
    //  Don't do the two following operations for the Root Dcb.
    //

    if ( NodeType(Fcb) != RDBSS_NTC_ROOT_DCB ) {

        POOL_TYPE PoolType;

        //
        //  If this happens to be a paging file, use non-paged pool for the FCB
        //

        if ( FlagOn( Fcb->FcbState, FCB_STATE_PAGING_FILE ) ) {

            PoolType = NonPagedPool;

        } else {

            PoolType = PagedPool;
        }

        //
        //  Reset the mcb mapping.
        //

        FsRtlRemoveMcbEntry( &Fcb->Mcb, 0, 0xFFFFFFFF );

        //
        //  Reset the allocation size to 0 or unknown
        //

        if ( Fcb->FirstClusterOfFile == 0 ) {

            Fcb->Header.AllocationSize = RxLargeZero;

        } else {

            Fcb->Header.AllocationSize.QuadPart = -1;
        }
    }

    //
    //  If this is a directory, reset the hints.
    //

    if ( (NodeType(Fcb) == RDBSS_NTC_DCB) ||
         (NodeType(Fcb) == RDBSS_NTC_ROOT_DCB) ) {

        //
        //  Force a rescan of the directory
        //

        Fcb->Specific.Dcb.UnusedDirentVbo = 0xffffffff;
        Fcb->Specific.Dcb.DeletedDirentHint = 0xffffffff;
    }
}



//
//  Internal support routine
//

VOID
RxDetermineAndMarkFcbCondition (
    IN PRX_CONTEXT RxContext,
    IN PFCB Fcb
    )

/*++

Routine Description:

    This routine checks a specific Fcb to see if it is different from what's
    on the disk.  The following things are checked:

        - File Name
        - File Size (if not directory)
        - First Cluster Of File
        - Dirent Attributes

Arguments:

    Fcb - Supplies the Fcb to examine

Return Value:

    None.

--*/

{
    PDIRENT Dirent;
    PBCB DirentBcb;

    OEM_STRING Name;
    CHAR Buffer[16];

    //
    //  If this is the Root Dcb, special case it.  That is, we know
    //  by definition that it is good since it is fixed in the volume
    //  structure.
    //

    if ( NodeType(Fcb) == RDBSS_NTC_ROOT_DCB ) {

        RxResetFcb( RxContext, Fcb );

        RxMarkFcbCondition( RxContext, Fcb, FcbGood );

        return;
    }

    //  The first thing we need to do to verify ourselves is
    //  locate the dirent on the disk.
    //

    RxGetDirentFromFcbOrDcb( RxContext,
                              Fcb,
                              &Dirent,
                              &DirentBcb );

    //
    //  We located the dirent for ourselves now make sure it
    //  is really ours by comparing the Name and RxFlags.
    //  Then for a file we also check the file size.
    //
    //  Note that we have to unpin the Bcb before calling RxResetFcb
    //  in order to avoid a deadlock in CcUninitializeCacheMap.
    //

    Name.MaximumLength = 16;
    Name.Buffer = &Buffer[0];

    Rx8dot3ToString( RxContext, Dirent, FALSE, &Name );

    if (!RtlEqualString( &Name, &Fcb->ShortName.Name.Oem, TRUE )

            ||

         ( (NodeType(Fcb) == RDBSS_NTC_FCB) &&
           (Fcb->Header.FileSize.LowPart != Dirent->FileSize) )

            ||

         ((ULONG)Dirent->FirstClusterOfFile != Fcb->FirstClusterOfFile)

            ||

          (Dirent->Attributes != Fcb->DirentRxFlags) ) {

        RxMarkFcbCondition( RxContext, Fcb, FcbBad );

        RxUnpinBcb( RxContext, DirentBcb );

    } else {

        //
        //  We passed.  Get the Fcb ready to use again.
        //

        RxUnpinBcb( RxContext, DirentBcb );

        RxResetFcb( RxContext, Fcb );

        RxMarkFcbCondition( RxContext, Fcb, FcbGood );
    }

    return;
}



//
//  Internal support routine
//

VOID
RxQuickVerifyVcb (
    IN PRX_CONTEXT RxContext,
    IN PVCB Vcb
    )

/*++

Routine Description:

    This routines just checks the verify bit in the real device and the
    Vcb condition and raises an appropriate exception if so warented.
    It is called when verifying both Fcbs and Vcbs.

Arguments:

    Vcb - Supplies the Vcb to check the condition of.

Return Value:

    None.

--*/

{
    RxCaptureRequestPacket;

    //
    //  If the real device needs to be verified we'll set the
    //  DeviceToVerify to be our real device and raise VerifyRequired.
    //

    if (FlagOn(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME)) {

        DebugTrace(0, Dbg, "The Vcb needs to be verified\n", 0);

        IoSetHardErrorOrVerifyDevice( capReqPacket,
                                      Vcb->Vpb->RealDevice );

        RxRaiseStatus( RxContext, RxStatus(VERIFY_REQUIRED) );
    }

    //
    //  Based on the condition of the Vcb we'll either return to our
    //  caller or raise an error condition
    //

    switch (Vcb->VcbCondition) {

    case VcbGood:

        DebugTrace(0, Dbg, "The Vcb is good\n", 0);

        //
        //  Do a check here of an operation that would try to modify a
        //  write protected media.
        //

        if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_WRITE_PROTECTED) &&
            ((RxContext->MajorFunction == IRP_MJ_WRITE) ||
             (RxContext->MajorFunction == IRP_MJ_SET_INFORMATION) ||
             (RxContext->MajorFunction == IRP_MJ_SET_EA) ||
             (RxContext->MajorFunction == IRP_MJ_FLUSH_BUFFERS) ||
             (RxContext->MajorFunction == IRP_MJ_SET_VOLUME_INFORMATION))) {

            //
            //  Set the real device for the pop-up info, and set the verify
            //  bit in the device object, so that we will force a verify
            //  in case the user put the correct media back in.
            //


            IoSetHardErrorOrVerifyDevice( capReqPacket,
                                          Vcb->Vpb->RealDevice );

            SetFlag(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME);

            RxRaiseStatus( RxContext, RxStatus(MEDIA_WRITE_PROTECTED) );
        }

        break;

    case VcbNotMounted:

        DebugTrace(0, Dbg, "The Vcb is not mounted\n", 0);

        //
        //  Set the real device for the pop-up info, and set the verify
        //  bit in the device object, so that we will force a verify
        //  in case the user put the correct media back in.
        //

        IoSetHardErrorOrVerifyDevice( capReqPacket,
                                      Vcb->Vpb->RealDevice );

        SetFlag(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME);

        RxRaiseStatus( RxContext, RxStatus(WRONG_VOLUME) );

        break;

    default:

        DebugDump("Invalid VcbCondition\n", 0, Vcb);
        RxBugCheck( Vcb->VcbCondition, 0, 0 );
    }
}

RXSTATUS
RxPerformVerify (
    IN PRX_CONTEXT RxContext,
    IN PIRP Irp,
    IN PDEVICE_OBJECT Device
    )

/*++

Routine Description:

    This routines performs an IoVerifyVolume operation and takes the
    appropriate action.  After the Verify is complete the originating
    Irp is sent off to an Ex Worker Thread.  This routine is called
    from the exception handler.

Arguments:

    Irp - The irp to send off after all is well and done.

    Device - The real device needing verification.

Return Value:

    None.

--*/

{
    PVCB Vcb;
    RXSTATUS Status = RxStatus(SUCCESS);
    RxCaptureParamBlock; RxCaptureFileObject;

    //
    //  Check if this Irp has a status of Verify required and if it does
    //  then call the I/O system to do a verify.
    //
    //  Skip the IoVerifyVolume if this is a mount or verify request
    //  itself.  Trying a recursive mount will cause a deadlock with
    //  the DeviceObject->DeviceLock.
    //

    if ( (RxContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL)

               &&

         ((RxContext->MinorFunction == IRP_MN_MOUNT_VOLUME) ||
          (RxContext->MinorFunction == IRP_MN_VERIFY_VOLUME)) ) {

        return RxFsdPostRequest( RxContext );
    }

    DebugTrace(0, Dbg, "Verify Required, DeviceObject = %08lx\n", Device);

    //
    //  Extract a pointer to the Vcb from the RxDeviceObject.
    //  Note that since we have specifically excluded mount,
    //  requests, we know that IrpSp->DeviceObject is indeed a
    //  volume device object.
    //

    Vcb = &CONTAINING_RECORD( capPARAMS->DeviceObject,
                              RDBSS_DEVICE_OBJECT,
                              DeviceObject )->Vcb;

    //
    //  Check if the volume still thinks it needs to be verified,
    //  if it doesn't then we can skip doing a verify because someone
    //  else beat us to it.
    //

    try {

        if (FlagOn(Device->Flags, DO_VERIFY_VOLUME)) {

            BOOLEAN AllowRawMount;
#ifdef WE_WON_ON_APPEAL
            PLIST_ENTRY Links;
#endif // WE_WON_ON_APPEAL

            //
            //  We will allow Raw to mount this volume if we were doing a
            //  a DASD open.
            //

            if ( (RxContext->MajorFunction == IRP_MJ_CREATE) &&
                 (capFileObject->FileName.Length == 0) &&
                 (capFileObject->RelatedFileObject == NULL) ) {

                AllowRawMount = TRUE;

            } else {

                AllowRawMount = FALSE;
            }

            //
            //  If the IopMount in IoVerifyVolume did something, and
            //  this is an absolute open, force a reparse.
            //

            Status = IoVerifyVolume( Device, AllowRawMount );

            //
            //  If the verify operation completed it will return
            //  either RxStatus(SUCCESS) or STATUS_WRONG_VOLUME, exactly.
            //
            //  If RxVerifyVolume encountered an error during
            //  processing, it will return that error.  If we got
            //  RxStatus(WRONG_VOLUME) from the verfy, and our volume
            //  is now mounted, commute the status to RxStatus(SUCCESS).
            //

            if ( (Status == RxStatus(WRONG_VOLUME)) &&
                 (Vcb->VcbCondition == VcbGood) ) {

                Status = RxStatus(SUCCESS);
            }

            //
            //  Do a quick unprotected check here.  The routine will do
            //  a safe check.  After here we can release the resource.
            //  Note that if the volume really went away, we will be taking
            //  the Reparse path.
            //

            (VOID)RxAcquireExclusiveGlobal( RxContext );

#ifdef WE_WON_ON_APPEAL

            //
            //  It is possible we were called with a double space Vcb.
            //  We need to start with the Parent Vcb at this point.
            //

            if (Vcb->Dscb) {

                Vcb = Vcb->Dscb->ParentVcb;
            }

            //
            //  First run through any mounted DBLS volumes.  Note that we
            //  have to get the next Flink before calling RxCheckForDismount
            //  incase the Vcb goes away.
            //

            (VOID)RxAcquireExclusiveVcb( RxContext, Vcb );

            for (Links = Vcb->ParentDscbLinks.Flink;
                 Links != &Vcb->ParentDscbLinks; ) {

                PVCB ChildVcb;

                ChildVcb = CONTAINING_RECORD( Links, DSCB, ChildDscbLinks )->Vcb;

                Links = Links->Flink;

                ASSERT( ChildVcb->Vpb->RealDevice == Vcb->Vpb->RealDevice );

                if ( (ChildVcb->VcbCondition == VcbNotMounted) &&
                     (ChildVcb->OpenFileCount == 0) ) {

                    (VOID)RxCheckForDismount( RxContext, ChildVcb );
                }
            }

            RxReleaseVcb( RxContext, Vcb );

#endif // WE_WON_ON_APPEAL

            if ( (Vcb->VcbCondition == VcbNotMounted) &&
                 (Vcb->OpenFileCount == 0) ) {

                (VOID)RxCheckForDismount( RxContext, Vcb );
            }

            RxReleaseGlobal( RxContext );

            if ((RxContext->MajorFunction == IRP_MJ_CREATE) &&
                (capFileObject->RelatedFileObject == NULL) &&
                ((Status == RxStatus(SUCCESS)) || (Status == STATUS_WRONG_VOLUME))) {

                Irp->IoStatus.Information = IO_REMOUNT;

                RxCompleteRequest( RxContext, RxStatus(REPARSE) );
                Status = RxStatus(REPARSE);
                Irp = NULL;
            }

            if ( (Irp != NULL) && !NT_SUCCESS(Status) ) {

                //
                //  Fill in the device object if required.
                //

                if ( IoIsErrorUserInduced( Status ) ) {

                    IoSetHardErrorOrVerifyDevice( Irp, Device );
                }

                RxNormalizeAndRaiseStatus( RxContext, Status );
            }

        } else {

            DebugTrace(0, Dbg, "Volume no longer needs verification\n", 0);
        }

        //
        //  If there is still an Irp, send it off to an Ex Worker thread.
        //

        if ( Irp != NULL ) {

            Status = RxFsdPostRequest( RxContext );
        }

    } except(RxExceptionFilter( RxContext, GetExceptionInformation() )) {

        //
        //  We had some trouble trying to perform the verify or raised
        //  an error ourselves.  So we'll abort the I/O request with
        //  the error status that we get back from the execption code.
        //

        Status = RxProcessException( RxContext, GetExceptionCode() );
    }

    return Status;
}

//
//  Local support routine
//

RXSTATUS
RxMarkDirtyCompletionRoutine(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Contxt
    )

{
    //
    //  Set the event so that our call will wake up.
    //

    KeSetEvent( (PKEVENT)Contxt, 0, FALSE );

    UNREFERENCED_PARAMETER( DeviceObject );
    UNREFERENCED_PARAMETER( Irp );

    return RxStatus(MORE_PROCESSING_REQUIRED);
}