verfysup.c File Reference

#include "cdprocs.h"

Include dependency graph for verfysup.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (CDFS_BUG_CHECK_VERFYSUP)

Functions
	_Requires_lock_held_ (_Global_critical_region_)
BOOLEAN	CdMarkDevForVerifyIfVcbMounted (_Inout_ PVCB Vcb)
VOID	CdVerifyVcb (_In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb)
BOOLEAN	CdVerifyFcbOperation (_In_opt_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb)

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (CDFS_BUG_CHECK_VERFYSUP)

Definition at line 22 of file verfysup.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 29 of file verfysup.c.

{
    PVCB Vcb;
    NTSTATUS Status = STATUS_SUCCESS;
    PIO_STACK_LOCATION IrpSp;
 
    ASSERT_IRP_CONTEXT( IrpContext );
    ASSERT_IRP( Irp );
 
    //
    //  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 ((IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL) &&
        ((IrpContext->MinorFunction == IRP_MN_MOUNT_VOLUME) ||
         (IrpContext->MinorFunction == IRP_MN_VERIFY_VOLUME))) {
 
        return CdFsdPostRequest( IrpContext, Irp );
    }
 
    //
    //  Extract a pointer to the Vcb from the VolumeDeviceObject.
    //  Note that since we have specifically excluded mount,
    //  requests, we know that IrpSp->DeviceObject is indeed a
    //  volume device object.
    //
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    Vcb = &CONTAINING_RECORD( IrpSp->DeviceObject,
                              VOLUME_DEVICE_OBJECT,
                              DeviceObject )->Vcb;
    _SEH2_TRY {
 
        //
        //  Send down the verify FSCTL.  Note that this is sent to the
        //  currently mounted volume,  which may not be this one.
        //
        //  We will allow Raw to mount this volume if we were doing a
        //  an absolute DASD open.
        //
 
        Status = IoVerifyVolume( DeviceToVerify, CdOperationIsDasdOpen( IrpContext));
 
        //
        //  Acquire the Vcb so we're working with a stable VcbCondition.
        //
 
        CdAcquireVcbShared( IrpContext, Vcb, FALSE);
 
        //
        //  If the verify operation completed it will return
        //  either STATUS_SUCCESS or STATUS_WRONG_VOLUME, exactly.
        //
        //  If CdVerifyVolume encountered an error during
        //  processing, it will return that error.  If we got
        //  STATUS_WRONG_VOLUME from the verify, and our volume
        //  is now mounted, commute the status to STATUS_SUCCESS.
        //
 
        if ((Status == STATUS_WRONG_VOLUME) &&
            (Vcb->VcbCondition == VcbMounted)) {
 
            Status = STATUS_SUCCESS;
        }
        else if ((STATUS_SUCCESS == Status) && (Vcb->VcbCondition != VcbMounted))  {
 
            //
            //  If the verify succeeded,  but our volume is not mounted,
            //  then some other volume is on the device.
            //
 
            Status = STATUS_WRONG_VOLUME;
        }
 
        //
        //  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.
        //
 
        //
        //  If the device might need to go away then call our dismount routine.
        //
 
        if (((Vcb->VcbCondition == VcbNotMounted) ||
             (Vcb->VcbCondition == VcbInvalid) ||
             (Vcb->VcbCondition == VcbDismountInProgress)) &&
            (Vcb->VcbReference <= CDFS_RESIDUAL_REFERENCE)) {
 
            CdReleaseVcb( IrpContext, Vcb);
 
            CdAcquireCdData( IrpContext );
            CdCheckForDismount( IrpContext, Vcb, FALSE );
            CdReleaseCdData( IrpContext );
        }
        else {
 
            CdReleaseVcb( IrpContext, Vcb);
        }
 
        //
        //  If this is a create and the verify succeeded then complete the
        //  request with a REPARSE status.
        //
 
        if ((IrpContext->MajorFunction == IRP_MJ_CREATE) &&
            (IrpSp->FileObject->RelatedFileObject == NULL) &&
            ((Status == STATUS_SUCCESS) || (Status == STATUS_WRONG_VOLUME))) {
 
            Irp->IoStatus.Information = IO_REMOUNT;
 
            CdCompleteRequest( IrpContext, Irp, STATUS_REPARSE );
            Status = STATUS_REPARSE;
            Irp = NULL;
            IrpContext = NULL;
 
        //
        //  If there is still an error to process then call the Io system
        //  for a popup.
        //
 
        } else if ((Irp != NULL) && !NT_SUCCESS( Status )) {
 
            //
            //  Fill in the device object if required.
            //
 
            if (IoIsErrorUserInduced( Status ) ) {
 
                IoSetHardErrorOrVerifyDevice( Irp, DeviceToVerify );
            }
 
            CdNormalizeAndRaiseStatus( IrpContext, Status );
        }
 
        //
        //  If there is still an Irp, send it off to an Ex Worker thread.
        //
 
        if (IrpContext != NULL) {
 
            Status = CdFsdPostRequest( IrpContext, Irp );
        }
 
    } _SEH2_EXCEPT(CdExceptionFilter( IrpContext, _SEH2_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 = CdProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
    } _SEH2_END;
 
    return Status;
}

CdMarkDevForVerifyIfVcbMounted()

BOOLEAN CdMarkDevForVerifyIfVcbMounted

(

_Inout_ PVCB

Vcb

)

Definition at line 359 of file verfysup.c.

{
    BOOLEAN Marked = FALSE;
    KIRQL SavedIrql;
 
    IoAcquireVpbSpinLock( &SavedIrql );
 
#ifdef _MSC_VER
#pragma prefast(suppress: 28175, "this is a filesystem driver, touching the vpb is allowed")
#endif
    if (Vcb->Vpb->RealDevice->Vpb == Vcb->Vpb)  {
 
        CdMarkRealDevForVerify( Vcb->Vpb->RealDevice);
        Marked = TRUE;
    }
    else {
 
        //
        //  Flag this to avoid the VPB spinlock in future passes.
        //
 
        SetFlag( Vcb->VcbState, VCB_STATE_VPB_NOT_ON_DEVICE);
    }
 
    IoReleaseVpbSpinLock( SavedIrql );
 
    return Marked;
}

Referenced by _Requires_lock_held_(), and CdVerifyVcb().

CdVerifyFcbOperation()

BOOLEAN CdVerifyFcbOperation	(	_In_opt_ PIRP_CONTEXT	IrpContext,
		_In_ PFCB	Fcb
	)

Definition at line 615 of file verfysup.c.

{
    PVCB Vcb = Fcb->Vcb;
    PDEVICE_OBJECT RealDevice = Vcb->Vpb->RealDevice;
    PIRP Irp;
 
    PAGED_CODE();
 
    //
    //  Check that the fileobject has not been cleaned up.
    //
 
    if ( ARGUMENT_PRESENT( IrpContext ))  {
 
        PFILE_OBJECT FileObject;
 
        Irp = IrpContext->Irp;
        FileObject = IoGetCurrentIrpStackLocation( Irp)->FileObject;
 
        if ( FileObject && FlagOn( FileObject->Flags, FO_CLEANUP_COMPLETE))  {
 
            PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
            //
            //  Following FAT,  we allow certain operations even on cleaned up
            //  file objects.  Everything else,  we fail.
            //
 
            if ( (FlagOn(Irp->Flags, IRP_PAGING_IO)) ||
                 (IrpSp->MajorFunction == IRP_MJ_CLOSE ) ||
                 (IrpSp->MajorFunction == IRP_MJ_QUERY_INFORMATION) ||
                 ( (IrpSp->MajorFunction == IRP_MJ_READ) &&
                   FlagOn(IrpSp->MinorFunction, IRP_MN_COMPLETE) ) ) {
 
                NOTHING;
 
            } else {
 
                CdRaiseStatus( IrpContext, STATUS_FILE_CLOSED );
            }
        }
    }
 
    //
    //  Fail immediately if the volume is in the progress of being dismounted
    //  or has been marked invalid.
    //
 
    if ((Vcb->VcbCondition == VcbInvalid) ||
        (Vcb->VcbCondition == VcbDismountInProgress)) {
 
        if (ARGUMENT_PRESENT( IrpContext )) {
 
            if (FlagOn( Vcb->VcbState, VCB_STATE_DISMOUNTED )) {
 
                CdRaiseStatus( IrpContext, STATUS_VOLUME_DISMOUNTED );
 
            } else {
 
                CdRaiseStatus( IrpContext, STATUS_FILE_INVALID );
            }
        }
 
        return FALSE;
    }
 
    //
    //  Always fail if the volume needs to be verified.
    //
 
    if (CdRealDevNeedsVerify( RealDevice)) {
 
        if (ARGUMENT_PRESENT( IrpContext )) {
 
            IoSetHardErrorOrVerifyDevice( IrpContext->Irp,
                                          RealDevice );
 
            CdRaiseStatus( IrpContext, STATUS_VERIFY_REQUIRED );
        }
 
        return FALSE;
 
    //
    //
    //  All operations are allowed on mounted.
    //
 
    } else if ((Vcb->VcbCondition == VcbMounted) ||
               (Vcb->VcbCondition == VcbMountInProgress)) {
 
        return TRUE;
 
    //
    //  Fail all requests for fast Io on other Vcb conditions.
    //
 
    } else if (!ARGUMENT_PRESENT( IrpContext )) {
 
        return FALSE;
 
    //
    //  The remaining case is VcbNotMounted.
    //  Mark the device to be verified and raise WRONG_VOLUME.
    //
 
    } else if (Vcb->VcbCondition == VcbNotMounted) {
 
        IoSetHardErrorOrVerifyDevice( IrpContext->Irp, RealDevice );
        CdRaiseStatus( IrpContext, STATUS_WRONG_VOLUME );
 
//        return FALSE; // unreachable code
    }
 
    return TRUE;
}

Referenced by _Function_class_(), _Requires_lock_held_(), CdCommonLockControl(), CdFastLock(), CdFastUnlockAll(), CdFastUnlockAllByKey(), and CdFastUnlockSingle().

CdVerifyVcb()

VOID CdVerifyVcb	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PVCB	Vcb
	)

Definition at line 411 of file verfysup.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    IO_STATUS_BLOCK Iosb;
    ULONG MediaChangeCount = 0;
    BOOLEAN ForceVerify = FALSE;
    BOOLEAN DevMarkedForVerify;
 
    PAGED_CODE();
 
    //
    //  Fail immediately if the volume is in the progress of being dismounted
    //  or has been marked invalid.
    //
 
    if ((Vcb->VcbCondition == VcbInvalid) ||
        ((Vcb->VcbCondition == VcbDismountInProgress) &&
         (IrpContext->MajorFunction != IRP_MJ_CREATE))) {
 
        if (FlagOn( Vcb->VcbState, VCB_STATE_DISMOUNTED )) {
 
            CdRaiseStatus( IrpContext, STATUS_VOLUME_DISMOUNTED );
 
        } else {
 
            CdRaiseStatus( IrpContext, STATUS_FILE_INVALID );
        }
    }
 
    //
    //  Capture the real device verify state.
    //
 
    DevMarkedForVerify = CdRealDevNeedsVerify( Vcb->Vpb->RealDevice);
 
    if (FlagOn( Vcb->VcbState, VCB_STATE_REMOVABLE_MEDIA ) && !DevMarkedForVerify) {
 
        //
        //  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.
        //
 
        if (Vcb->VcbCondition != VcbMountInProgress) {
 
            Status = CdPerformDevIoCtrl( IrpContext,
                                         IOCTL_CDROM_CHECK_VERIFY,
                                         Vcb->TargetDeviceObject,
                                         &MediaChangeCount,
                                         sizeof(ULONG),
                                         FALSE,
                                         FALSE,
                                         &Iosb );
 
            if (Iosb.Information != sizeof(ULONG)) {
 
                //
                //  Be safe about the count in case the driver didn't fill it in
                //
 
                MediaChangeCount = 0;
            }
 
            //
            //  There are four cases when we want to do a verify.  These are the
            //  first three.
            //
            //  1. We are mounted,  and the device has become empty
            //  2. The device has returned verify required (=> DO_VERIFY_VOL flag is
            //     set, but could be due to hardware condition)
            //  3. Media change count doesn't match the one in the Vcb
            //
 
            if (((Vcb->VcbCondition == VcbMounted) &&
                 CdIsRawDevice( IrpContext, Status ))
                ||
                (Status == STATUS_VERIFY_REQUIRED)
                ||
                (NT_SUCCESS(Status) &&
                 (Vcb->MediaChangeCount != MediaChangeCount))) {
 
                //
                //  If we are currently the volume on the device then it is our
                //  responsibility to set the verify flag.  If we're not on the device,
                //  then we shouldn't touch the flag.
                //
 
                if (!FlagOn( Vcb->VcbState, VCB_STATE_VPB_NOT_ON_DEVICE) &&
                    !DevMarkedForVerify)  {
 
                     DevMarkedForVerify = CdMarkDevForVerifyIfVcbMounted( Vcb);
                }
 
                ForceVerify = TRUE;
 
                //
                //  NOTE that we no longer update the media change count here. We
                //  do so only when we've actually completed a verify at a particular
                //  change count value.
                //
            }
        }
 
        //
        //  This is the 4th verify case.
        //
        //  We ALWAYS force CREATE requests on unmounted volumes through the
        //  verify path.  These requests could have been in limbo between
        //  IoCheckMountedVpb and us when a verify/mount took place and caused
        //  a completely different fs/volume to be mounted.  In this case the
        //  checks above may not have caught the condition,  since we may already
        //  have verified (wrong volume) and decided that we have nothing to do.
        //  We want the requests to be re routed to the currently mounted volume,
        //  since they were directed at the 'drive',  not our volume.
        //
 
        if (NT_SUCCESS( Status) && !ForceVerify && !DevMarkedForVerify &&
            (IrpContext->MajorFunction == IRP_MJ_CREATE))  {
 
            PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( IrpContext->Irp);
 
            ForceVerify = (IrpSp->FileObject->RelatedFileObject == NULL) &&
                          ((Vcb->VcbCondition == VcbDismountInProgress) ||
                           (Vcb->VcbCondition == VcbNotMounted));
 
            //
            //  Note that we don't touch the device verify flag here.  It required
            //  it would have been caught and set by the first set of checks.
            //
        }
    }
 
    //
    //  Raise the verify / error if neccessary.
    //
 
    if (ForceVerify || DevMarkedForVerify || !NT_SUCCESS( Status)) {
 
        IoSetHardErrorOrVerifyDevice( IrpContext->Irp,
                                      Vcb->Vpb->RealDevice );
 
        CdRaiseStatus( IrpContext, (ForceVerify || DevMarkedForVerify)
                                   ? STATUS_VERIFY_REQUIRED
                                   : Status);
    }
 
    //
    //  Based on the condition of the Vcb we'll either return to our
    //  caller or raise an error condition
    //
 
    switch (Vcb->VcbCondition) {
 
    case VcbNotMounted:
 
        IoSetHardErrorOrVerifyDevice( IrpContext->Irp, Vcb->Vpb->RealDevice );
 
        CdRaiseStatus( IrpContext, STATUS_WRONG_VOLUME );
        break;
 
    case VcbInvalid:
    case VcbDismountInProgress:
 
        if (FlagOn( Vcb->VcbState, VCB_STATE_DISMOUNTED )) {
 
            CdRaiseStatus( IrpContext, STATUS_VOLUME_DISMOUNTED );
 
        } else {
 
            CdRaiseStatus( IrpContext, STATUS_FILE_INVALID );
        }
        break;
 
    /* ReactOS Change: GCC "enumeration value not handled in switch" */
    default: break;
    }
}

Referenced by CdCommonDevControl(), and CdIsVolumeMounted().