mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1757 lines
39 KiB
1757 lines
39 KiB
/*++
|
|
|
|
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);
|
|
}
|
|
|