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.
1835 lines
45 KiB
1835 lines
45 KiB
/*++
|
|
|
|
Copyright (c) 1989-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
VerfySup.c
|
|
|
|
Abstract:
|
|
|
|
This module implements the Fat Verify volume and fcb/dcb support
|
|
routines
|
|
|
|
// @@BEGIN_DDKSPLIT
|
|
|
|
Author:
|
|
|
|
Gary Kimura [GaryKi] 01-Jun-1990
|
|
|
|
Revision History:
|
|
|
|
// @@END_DDKSPLIT
|
|
|
|
--*/
|
|
|
|
#include "FatProcs.h"
|
|
|
|
//
|
|
// The Bug check file id for this module
|
|
//
|
|
|
|
#define BugCheckFileId (FAT_BUG_CHECK_VERFYSUP)
|
|
|
|
//
|
|
// The Debug trace level for this module
|
|
//
|
|
|
|
#define Dbg (DEBUG_TRACE_VERFYSUP)
|
|
|
|
//
|
|
// Local procedure prototypes
|
|
//
|
|
|
|
VOID
|
|
FatResetFcb (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
IN PFCB Fcb
|
|
);
|
|
|
|
VOID
|
|
FatDetermineAndMarkFcbCondition (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
IN PFCB Fcb
|
|
);
|
|
|
|
VOID
|
|
FatDeferredCleanVolume (
|
|
PVOID Parameter
|
|
);
|
|
|
|
NTSTATUS
|
|
FatMarkVolumeCompletionRoutine(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PVOID Contxt
|
|
);
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE, FatCheckDirtyBit)
|
|
#pragma alloc_text(PAGE, FatVerifyOperationIsLegal)
|
|
#pragma alloc_text(PAGE, FatDeferredCleanVolume)
|
|
#pragma alloc_text(PAGE, FatDetermineAndMarkFcbCondition)
|
|
#pragma alloc_text(PAGE, FatQuickVerifyVcb)
|
|
#pragma alloc_text(PAGE, FatPerformVerify)
|
|
#pragma alloc_text(PAGE, FatMarkFcbCondition)
|
|
#pragma alloc_text(PAGE, FatResetFcb)
|
|
#pragma alloc_text(PAGE, FatVerifyVcb)
|
|
#pragma alloc_text(PAGE, FatVerifyFcb)
|
|
#endif
|
|
|
|
|
|
VOID
|
|
FatMarkFcbCondition (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
IN PFCB Fcb,
|
|
IN FCB_CONDITION FcbCondition,
|
|
IN BOOLEAN Recursive
|
|
)
|
|
|
|
/*++
|
|
|
|
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
|
|
|
|
Recursive - Specifies whether this condition should be applied to
|
|
all children (see the case where we are invalidating a live volume
|
|
for a case where this is now desireable).
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
DebugTrace(+1, Dbg, "FatMarkFcbCondition, 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 :
|
|
FatVcbAcquiredExclusive(IrpContext, 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: %Z\n", &Fcb->FullFileName);
|
|
|
|
//
|
|
// This FastIo flag is based on FcbCondition, so update it now. This only
|
|
// applies to regular FCBs, of course.
|
|
//
|
|
|
|
if (Fcb->Header.NodeTypeCode == FAT_NTC_FCB) {
|
|
|
|
Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( 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)) &&
|
|
Recursive &&
|
|
((Fcb->Header.NodeTypeCode == FAT_NTC_DCB) ||
|
|
(Fcb->Header.NodeTypeCode == FAT_NTC_ROOT_DCB)) ) {
|
|
|
|
PFCB OriginalFcb = Fcb;
|
|
|
|
while ( (Fcb = FatGetNextFcbTopDown(IrpContext, Fcb, OriginalFcb)) != NULL ) {
|
|
|
|
DebugTrace(0, Dbg, "MarkFcb: %Z\n", &Fcb->FullFileName);
|
|
|
|
Fcb->FcbCondition = FcbCondition;
|
|
|
|
//
|
|
// We already know that FastIo is not possible since we are propagating
|
|
// a parent's bad/verify flag down the tree - IO to the children must
|
|
// take the long route for now.
|
|
//
|
|
|
|
Fcb->Header.IsFastIoPossible = FastIoIsNotPossible;
|
|
}
|
|
}
|
|
|
|
DebugTrace(-1, Dbg, "FatMarkFcbCondition -> VOID\n", 0);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
FatVerifyVcb (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
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.
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG ChangeCount = 0;
|
|
|
|
DebugTrace(+1, Dbg, "FatVerifyVcb, 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) ) {
|
|
|
|
IO_STATUS_BLOCK Iosb;
|
|
NTSTATUS Status;
|
|
|
|
Status = FatPerformDevIoCtrl( IrpContext,
|
|
IOCTL_DISK_CHECK_VERIFY,
|
|
Vcb->TargetDeviceObject,
|
|
&ChangeCount,
|
|
sizeof(ULONG),
|
|
FALSE,
|
|
TRUE,
|
|
&Iosb );
|
|
|
|
//
|
|
// Verify potentially empty devices, explicit verify requests and
|
|
// when we get the secondary indication of media change via the
|
|
// device change count.
|
|
//
|
|
|
|
if ((Vcb->VcbCondition == VcbGood &&
|
|
FatIsRawDevice( IrpContext, Status )) ||
|
|
(Status == STATUS_VERIFY_REQUIRED) ||
|
|
(NT_SUCCESS(Status) &&
|
|
(Vcb->ChangeCount != ChangeCount))) {
|
|
|
|
SetFlag( Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME );
|
|
}
|
|
|
|
//
|
|
// Raise the error condition otherwise.
|
|
//
|
|
|
|
else if (!NT_SUCCESS( Status )) {
|
|
|
|
FatNormalizeAndRaiseStatus( IrpContext, Status );
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Now that the verify bit has been appropriately set, check the Vcb.
|
|
//
|
|
|
|
FatQuickVerifyVcb( IrpContext, Vcb );
|
|
|
|
DebugTrace(-1, Dbg, "FatVerifyVcb -> VOID\n", 0);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
FatVerifyFcb (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
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, "FatVerifyFcb, Vcb = %08lx\n", Fcb );
|
|
|
|
//
|
|
// Always refuse operations on dismounted volumes.
|
|
//
|
|
|
|
if (FlagOn( Fcb->Vcb->VcbState, VCB_STATE_FLAG_VOLUME_DISMOUNTED )) {
|
|
|
|
FatRaiseStatus( IrpContext, STATUS_VOLUME_DISMOUNTED );
|
|
}
|
|
|
|
//
|
|
// 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.
|
|
// The only caller we really have to worry about is the AdvanceOnly
|
|
// callback for setting valid data length from Cc, this will happen after
|
|
// cleanup (and file deletion), just before the SCM is ripped down.
|
|
//
|
|
|
|
if (IsFileDeleted( IrpContext, Fcb ) ||
|
|
((NodeType(Fcb) != FAT_NTC_ROOT_DCB) &&
|
|
IsFileDeleted( IrpContext, 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() ) {
|
|
|
|
FatQuickVerifyVcb( IrpContext, 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:
|
|
|
|
FatRaiseStatus( IrpContext, STATUS_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) {
|
|
|
|
FatDetermineAndMarkFcbCondition(IrpContext, 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) == FAT_NTC_ROOT_DCB) ) {
|
|
|
|
break;
|
|
}
|
|
|
|
CurrentFcb = CurrentFcb->ParentDcb;
|
|
}
|
|
|
|
//
|
|
// Now we can just look at ourselves to see how we did.
|
|
//
|
|
|
|
if (Fcb->FcbCondition != FcbGood) {
|
|
|
|
FatRaiseStatus( IrpContext, STATUS_FILE_INVALID );
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
DebugDump("Invalid FcbCondition\n", 0, Fcb);
|
|
FatBugCheck( Fcb->FcbCondition, 0, 0 );
|
|
}
|
|
|
|
DebugTrace(-1, Dbg, "FatVerifyFcb -> VOID\n", 0);
|
|
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
FatDeferredCleanVolume (
|
|
PVOID Parameter
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the routine that performs the actual FatMarkVolumeClean 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;
|
|
IRP_CONTEXT IrpContext;
|
|
BOOLEAN VcbExists = FALSE;
|
|
|
|
DebugTrace(+1, Dbg, "FatDeferredCleanVolume\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( &IrpContext, sizeof(IRP_CONTEXT));
|
|
|
|
SetFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
|
|
|
|
//
|
|
// Acquire shared access to the global lock and make sure this volume
|
|
// still exists.
|
|
//
|
|
|
|
FatAcquireSharedGlobal( &IrpContext );
|
|
|
|
for (Links = FatData.VcbQueue.Flink;
|
|
Links != &FatData.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) &&
|
|
!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_SHUTDOWN) ) {
|
|
|
|
try {
|
|
|
|
if (!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY)) {
|
|
|
|
FatMarkVolume( &IrpContext, Vcb, VolumeClean );
|
|
}
|
|
|
|
//
|
|
// Check for a pathological race condition, and fix it.
|
|
//
|
|
|
|
if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_VOLUME_DIRTY)) {
|
|
|
|
FatMarkVolume( &IrpContext, Vcb, VolumeDirty );
|
|
|
|
} 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)) {
|
|
|
|
FatToggleMediaEjectDisable( &IrpContext, Vcb, FALSE );
|
|
}
|
|
}
|
|
|
|
} except( FsRtlIsNtstatusExpected(GetExceptionCode()) ?
|
|
EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) {
|
|
|
|
NOTHING;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release the global resource, unpin and repinned Bcbs and return.
|
|
//
|
|
|
|
FatReleaseGlobal( &IrpContext );
|
|
|
|
try {
|
|
|
|
FatUnpinRepinnedBcbs( &IrpContext );
|
|
|
|
} except( FsRtlIsNtstatusExpected(GetExceptionCode()) ?
|
|
EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) {
|
|
|
|
NOTHING;
|
|
}
|
|
|
|
IoSetTopLevelIrp( NULL );
|
|
|
|
//
|
|
// and finally free the packet.
|
|
//
|
|
|
|
ExFreePool( Packet );
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
FatCleanVolumeDpc (
|
|
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 = (LONG)-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, &FatDeferredCleanVolume, Packet );
|
|
|
|
ExQueueWorkItem( &Packet->Item, CriticalWorkQueue );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
FatMarkVolume (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
IN PVCB Vcb,
|
|
IN FAT_VOLUME_STATE VolumeState
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine moves the physically marked volume state between the clean
|
|
and dirty states. For compatibility with Win9x, we manipulate both the
|
|
historical DOS (on==clean in index 1 of the FAT) and NT (on==dirty in
|
|
the CurrentHead field of the BPB) dirty bits.
|
|
|
|
Arguments:
|
|
|
|
Vcb - Supplies the Vcb being modified
|
|
|
|
VolumeState - Supplies the state the volume is transitioning to
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCHAR Sector;
|
|
PBCB Bcb = NULL;
|
|
KEVENT Event;
|
|
PIRP Irp = NULL;
|
|
NTSTATUS Status;
|
|
BOOLEAN FsInfoUpdate = FALSE;
|
|
ULONG FsInfoOffset;
|
|
ULONG ThisPass;
|
|
LARGE_INTEGER Offset;
|
|
|
|
DebugTrace(+1, Dbg, "FatMarkVolume, Vcb = %08lx\n", Vcb);
|
|
|
|
//
|
|
// We had best not be trying to scribble dirty/clean bits if the
|
|
// volume is write protected. The responsibility lies with the
|
|
// callers to make sure that operations that could cause a state
|
|
// change cannot happen. There are a few, though, that show it
|
|
// just doesn't make sense to force everyone to do the dinky
|
|
// check.
|
|
//
|
|
|
|
//
|
|
// If we were called for FAT12 or readonly media, return immediately.
|
|
//
|
|
|
|
if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_WRITE_PROTECTED) ||
|
|
FatIsFat12( Vcb )) {
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// We have two possible additional tasks to do to mark a volume
|
|
//
|
|
// Pass 0) Flip the dirty bit in the Bpb
|
|
// Pass 1) Rewrite the FsInfo sector for FAT32 if needed
|
|
//
|
|
// In most cases we can collapse these two either because the volume
|
|
// is either not FAT32 or the FsInfo sector is adjacent to the boot sector.
|
|
//
|
|
|
|
for (ThisPass = 0; ThisPass < 2; ThisPass++) {
|
|
|
|
//
|
|
// If this volume is being dirtied, or isn't FAT32, or if it is and
|
|
// we were able to perform the fast update, or the bpb lied to us
|
|
// about where the FsInfo went, we're done - no FsInfo to update in
|
|
// a seperate write.
|
|
//
|
|
|
|
if (ThisPass == 1 && (!FatIsFat32( Vcb ) ||
|
|
VolumeState != VolumeClean ||
|
|
FsInfoUpdate ||
|
|
Vcb->Bpb.FsInfoSector == 0)) {
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Bail if we get an IO error.
|
|
//
|
|
|
|
try {
|
|
|
|
ULONG PinLength;
|
|
ULONG WriteLength;
|
|
|
|
//
|
|
// If the FAT table is 12-bit then our strategy is to pin the entire
|
|
// thing when any of it is modified. Here we're going to pin the
|
|
// first page, so in the 12-bit case we also want to pin the rest
|
|
// of the FAT table.
|
|
//
|
|
|
|
Offset.QuadPart = 0;
|
|
|
|
if (Vcb->AllocationSupport.FatIndexBitSize == 12) {
|
|
|
|
//
|
|
// But we only write back the first sector.
|
|
//
|
|
|
|
PinLength = FatReservedBytes(&Vcb->Bpb) + FatBytesPerFat(&Vcb->Bpb);
|
|
WriteLength = Vcb->Bpb.BytesPerSector;
|
|
|
|
} else {
|
|
|
|
WriteLength = PinLength = Vcb->Bpb.BytesPerSector;
|
|
|
|
//
|
|
// If this is a FAT32 volume going into the clean state,
|
|
// see about doing the FsInfo sector.
|
|
//
|
|
|
|
if (FatIsFat32( Vcb ) && VolumeState == VolumeClean) {
|
|
|
|
//
|
|
// If the FsInfo sector immediately follows the boot sector,
|
|
// we can do this in a single operation by rewriting both
|
|
// sectors at once.
|
|
//
|
|
|
|
if (Vcb->Bpb.FsInfoSector == 1) {
|
|
|
|
ASSERT( ThisPass == 0 );
|
|
|
|
FsInfoUpdate = TRUE;
|
|
FsInfoOffset = Vcb->Bpb.BytesPerSector;
|
|
WriteLength = PinLength = Vcb->Bpb.BytesPerSector * 2;
|
|
|
|
} else if (ThisPass == 1) {
|
|
|
|
//
|
|
// We are doing an explicit write to the FsInfo sector.
|
|
//
|
|
|
|
FsInfoUpdate = TRUE;
|
|
FsInfoOffset = 0;
|
|
|
|
Offset.QuadPart = Vcb->Bpb.BytesPerSector * Vcb->Bpb.FsInfoSector;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Call Cc directly here so that we can avoid overhead and push this
|
|
// right down to the disk.
|
|
//
|
|
|
|
CcPinRead( Vcb->VirtualVolumeFile,
|
|
&Offset,
|
|
PinLength,
|
|
TRUE,
|
|
&Bcb,
|
|
(PVOID *)&Sector );
|
|
|
|
DbgDoit( IrpContext->PinCount += 1 )
|
|
|
|
//
|
|
// Set the Bpb on Pass 0 always
|
|
//
|
|
|
|
if (ThisPass == 0) {
|
|
|
|
PCHAR CurrentHead;
|
|
|
|
//
|
|
// Before we do anything, doublecheck that this still looks like a
|
|
// FAT bootsector. If it doesn't, something remarkable happened
|
|
// and we should avoid touching the volume.
|
|
//
|
|
// THIS IS TEMPORARY (but may last a while)
|
|
//
|
|
|
|
if (!FatIsBootSectorFat( (PPACKED_BOOT_SECTOR) Sector )) {
|
|
|
|
return;
|
|
}
|
|
|
|
if (FatIsFat32( Vcb )) {
|
|
|
|
CurrentHead = &((PPACKED_BOOT_SECTOR_EX) Sector)->CurrentHead;
|
|
|
|
} else {
|
|
|
|
CurrentHead = &((PPACKED_BOOT_SECTOR) Sector)->CurrentHead;
|
|
}
|
|
|
|
if (VolumeState == VolumeClean) {
|
|
|
|
ClearFlag( *CurrentHead, FAT_BOOT_SECTOR_DIRTY );
|
|
|
|
} else {
|
|
|
|
SetFlag( *CurrentHead, FAT_BOOT_SECTOR_DIRTY );
|
|
|
|
//
|
|
// In addition, if this request received an error that may indicate
|
|
// media corruption, have autochk perform a surface test.
|
|
//
|
|
|
|
if ( VolumeState == VolumeDirtyWithSurfaceTest ) {
|
|
|
|
SetFlag( *CurrentHead, FAT_BOOT_SECTOR_TEST_SURFACE );
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Update the FsInfo as appropriate.
|
|
//
|
|
|
|
if (FsInfoUpdate) {
|
|
|
|
PFSINFO_SECTOR FsInfoSector = (PFSINFO_SECTOR) ((PCHAR)Sector + FsInfoOffset);
|
|
|
|
//
|
|
// We just rewrite all of the spec'd fields. Note that we don't
|
|
// care to synchronize with the allocation package - this will be
|
|
// quickly taken care of by a re-dirtying of the volume if a change
|
|
// is racing with us. Remember that this is all a compatibility
|
|
// deference for Win9x FAT32 - NT will never look at this information.
|
|
//
|
|
|
|
FsInfoSector->SectorBeginSignature = FSINFO_SECTOR_BEGIN_SIGNATURE;
|
|
FsInfoSector->FsInfoSignature = FSINFO_SIGNATURE;
|
|
FsInfoSector->FreeClusterCount = Vcb->AllocationSupport.NumberOfFreeClusters;
|
|
FsInfoSector->NextFreeCluster = Vcb->ClusterHint;
|
|
FsInfoSector->SectorEndSignature = FSINFO_SECTOR_END_SIGNATURE;
|
|
}
|
|
|
|
//
|
|
// Initialize the event we're going to use
|
|
//
|
|
|
|
KeInitializeEvent( &Event, NotificationEvent, FALSE );
|
|
|
|
//
|
|
// Build the irp for the operation and also set the override 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.
|
|
//
|
|
|
|
Irp = IoBuildAsynchronousFsdRequest( IRP_MJ_WRITE,
|
|
Vcb->TargetDeviceObject,
|
|
(PVOID)Sector,
|
|
WriteLength,
|
|
&Offset,
|
|
NULL );
|
|
|
|
if ( Irp == NULL ) {
|
|
|
|
try_return(NOTHING);
|
|
}
|
|
|
|
//
|
|
// Make this operation write-through. It never hurts to try to be
|
|
// safer about this, even though we aren't logged.
|
|
//
|
|
|
|
SetFlag( IoGetNextIrpStackLocation( Irp )->Flags, SL_WRITE_THROUGH );
|
|
|
|
//
|
|
// Set up the completion routine
|
|
//
|
|
|
|
IoSetCompletionRoutine( Irp,
|
|
FatMarkVolumeCompletionRoutine,
|
|
&Event,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE );
|
|
|
|
//
|
|
// Call the device to do the write and wait for it to finish.
|
|
// Igmore any return status.
|
|
//
|
|
|
|
Status = IoCallDriver( Vcb->TargetDeviceObject, Irp );
|
|
|
|
if (Status == STATUS_PENDING) {
|
|
|
|
(VOID)KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, (PLARGE_INTEGER)NULL );
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
} 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 (Bcb != NULL) {
|
|
|
|
FatUnpinBcb( IrpContext, Bcb );
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Flip the dirty bit in the FAT
|
|
//
|
|
|
|
if (VolumeState == VolumeDirty) {
|
|
|
|
FatSetFatEntry( IrpContext, Vcb, FAT_DIRTY_BIT_INDEX, FAT_DIRTY_VOLUME);
|
|
|
|
} else {
|
|
|
|
FatSetFatEntry( IrpContext, Vcb, FAT_DIRTY_BIT_INDEX, FAT_CLEAN_VOLUME);
|
|
}
|
|
|
|
DebugTrace(-1, Dbg, "FatMarkVolume -> VOID\n", 0);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
FatFspMarkVolumeDirtyWithRecover(
|
|
PVOID Parameter
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the routine that performs the actual FatMarkVolume Dirty call
|
|
on a 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 FatMarkVolume()) 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;
|
|
IRP_CONTEXT IrpContext;
|
|
PIRP Irp;
|
|
BOOLEAN VcbExists = FALSE;
|
|
|
|
DebugTrace(+1, Dbg, "FatDeferredCleanVolume\n", 0);
|
|
|
|
Packet = (PCLEAN_AND_DIRTY_VOLUME_PACKET)Parameter;
|
|
|
|
Vcb = Packet->Vcb;
|
|
Irp = Packet->Irp;
|
|
|
|
//
|
|
// Dummy up the IrpContext so we can call our worker routines
|
|
//
|
|
|
|
RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT));
|
|
|
|
SetFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
|
|
IrpContext.OriginatingIrp = 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 );
|
|
|
|
FatMarkVolume( &IrpContext, Vcb, VolumeDirtyWithSurfaceTest );
|
|
|
|
} except(FatExceptionFilter( &IrpContext, GetExceptionInformation() )) {
|
|
|
|
NOTHING;
|
|
}
|
|
|
|
IoSetTopLevelIrp( NULL );
|
|
|
|
//
|
|
// Now complete the originating Irp or set the synchronous event.
|
|
//
|
|
|
|
if (Packet->Event) {
|
|
KeSetEvent( Packet->Event, 0, FALSE );
|
|
} else {
|
|
IoCompleteRequest( Irp, IO_DISK_INCREMENT );
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
FatCheckDirtyBit (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
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;
|
|
|
|
PPACKED_BOOT_SECTOR BootSector;
|
|
PBCB BootSectorBcb;
|
|
|
|
UNICODE_STRING VolumeLabel;
|
|
|
|
//
|
|
// Look in the boot sector
|
|
//
|
|
|
|
FatReadVolumeFile( IrpContext,
|
|
Vcb,
|
|
0,
|
|
sizeof(PACKED_BOOT_SECTOR),
|
|
&BootSectorBcb,
|
|
(PVOID *)&BootSector );
|
|
|
|
try {
|
|
|
|
//
|
|
// Check if the magic bit is set
|
|
//
|
|
|
|
if (IsBpbFat32(&BootSector->PackedBpb)) {
|
|
Dirty = BooleanFlagOn( ((PPACKED_BOOT_SECTOR_EX)BootSector)->CurrentHead,
|
|
FAT_BOOT_SECTOR_DIRTY );
|
|
} else {
|
|
Dirty = BooleanFlagOn( BootSector->CurrentHead, FAT_BOOT_SECTOR_DIRTY );
|
|
}
|
|
|
|
//
|
|
// Setup the VolumeLabel string
|
|
//
|
|
|
|
VolumeLabel.Length = Vcb->Vpb->VolumeLabelLength;
|
|
VolumeLabel.MaximumLength = MAXIMUM_VOLUME_LABEL_LENGTH;
|
|
VolumeLabel.Buffer = &Vcb->Vpb->VolumeLabel[0];
|
|
|
|
if ( Dirty ) {
|
|
|
|
//
|
|
// Do not trigger the mounted dirty bit if this is a verify
|
|
// and the volume is a boot or paging device. We know that
|
|
// a boot or paging device cannot leave the system, and thus
|
|
// that on its mount we will have figured this out correctly.
|
|
//
|
|
// This logic is a reasonable hack-o-rama to make BillG happy
|
|
// since his machine ran chkdsk after he installed Beta 3. Why?
|
|
// 'cause setup cracked a non-exclusive DASD handle near the
|
|
// end of setup, wrote some data, closed the handle and we
|
|
// set the verify bit ... came back around and saw that other
|
|
// arbitrary activity had left the volume in a temporarily dirty
|
|
// state.
|
|
//
|
|
// Of course, the real problem is that we don't have a journal.
|
|
//
|
|
|
|
if (!(IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL &&
|
|
IrpContext->MinorFunction == IRP_MN_VERIFY_VOLUME &&
|
|
FlagOn( Vcb->VcbState, VCB_STATE_FLAG_BOOT_OR_PAGING_FILE))) {
|
|
|
|
KdPrintEx((DPFLTR_FASTFAT_ID,
|
|
DPFLTR_INFO_LEVEL,
|
|
"FASTFAT: WARNING! Mounting Dirty Volume %Z\n",
|
|
&VolumeLabel));
|
|
|
|
SetFlag( Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY );
|
|
}
|
|
|
|
} else {
|
|
|
|
if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY)) {
|
|
|
|
KdPrintEx((DPFLTR_FASTFAT_ID,
|
|
DPFLTR_INFO_LEVEL,
|
|
"FASTFAT: Volume %Z has been cleaned.\n",
|
|
&VolumeLabel));
|
|
|
|
ClearFlag( Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY );
|
|
|
|
} else {
|
|
|
|
(VOID)FsRtlBalanceReads( Vcb->TargetDeviceObject );
|
|
}
|
|
}
|
|
|
|
} finally {
|
|
|
|
FatUnpinBcb( IrpContext, BootSectorBcb );
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
FatVerifyOperationIsLegal (
|
|
IN PIRP_CONTEXT IrpContext
|
|
)
|
|
|
|
/*++
|
|
|
|
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.
|
|
|
|
--*/
|
|
|
|
{
|
|
PIRP Irp;
|
|
PFILE_OBJECT FileObject;
|
|
|
|
Irp = IrpContext->OriginatingIrp;
|
|
|
|
//
|
|
// If the Irp is not present, then we got here via close.
|
|
//
|
|
//
|
|
|
|
if ( Irp == NULL ) {
|
|
|
|
return;
|
|
}
|
|
|
|
FileObject = IoGetCurrentIrpStackLocation(Irp)->FileObject;
|
|
|
|
//
|
|
// If there is not a file object, we cannot continue.
|
|
//
|
|
|
|
if ( FileObject == NULL ) {
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// 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 STATUS_FILE_CLOSED.
|
|
//
|
|
|
|
if ( FlagOn(FileObject->Flags, FO_CLEANUP_COMPLETE) ) {
|
|
|
|
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
|
|
|
if ( (FlagOn(Irp->Flags, IRP_PAGING_IO)) ||
|
|
(IrpSp->MajorFunction == IRP_MJ_CLOSE ) ||
|
|
(IrpSp->MajorFunction == IRP_MJ_SET_INFORMATION) ||
|
|
(IrpSp->MajorFunction == IRP_MJ_QUERY_INFORMATION) ||
|
|
( ( (IrpSp->MajorFunction == IRP_MJ_READ) ||
|
|
(IrpSp->MajorFunction == IRP_MJ_WRITE) ) &&
|
|
FlagOn(IrpSp->MinorFunction, IRP_MN_COMPLETE) ) ) {
|
|
|
|
NOTHING;
|
|
|
|
} else {
|
|
|
|
FatRaiseStatus( IrpContext, STATUS_FILE_CLOSED );
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Internal support routine
|
|
//
|
|
|
|
VOID
|
|
FatResetFcb (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
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
|
|
// or paging files. Paging files!? Yes, if someone diddles
|
|
// a volume we try to reverify all of the Fcbs just in case;
|
|
// however, there is no safe way to chuck and retrieve the
|
|
// mapping pair information for the paging file. Lose it and
|
|
// die.
|
|
//
|
|
|
|
if ( NodeType(Fcb) != FAT_NTC_ROOT_DCB &&
|
|
!FlagOn( Fcb->FcbState, FCB_STATE_PAGING_FILE )) {
|
|
|
|
//
|
|
// Reset the mcb mapping.
|
|
//
|
|
|
|
FsRtlRemoveLargeMcbEntry( &Fcb->Mcb, 0, 0xFFFFFFFF );
|
|
|
|
//
|
|
// Reset the allocation size to 0 or unknown
|
|
//
|
|
|
|
if ( Fcb->FirstClusterOfFile == 0 ) {
|
|
|
|
Fcb->Header.AllocationSize.QuadPart = 0;
|
|
|
|
} else {
|
|
|
|
Fcb->Header.AllocationSize.QuadPart = FCB_LOOKUP_ALLOCATIONSIZE_HINT;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If this is a directory, reset the hints.
|
|
//
|
|
|
|
if ( (NodeType(Fcb) == FAT_NTC_DCB) ||
|
|
(NodeType(Fcb) == FAT_NTC_ROOT_DCB) ) {
|
|
|
|
//
|
|
// Force a rescan of the directory
|
|
//
|
|
|
|
Fcb->Specific.Dcb.UnusedDirentVbo = 0xffffffff;
|
|
Fcb->Specific.Dcb.DeletedDirentHint = 0xffffffff;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Internal support routine
|
|
//
|
|
|
|
VOID
|
|
FatDetermineAndMarkFcbCondition (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
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;
|
|
ULONG FirstClusterOfFile;
|
|
|
|
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) == FAT_NTC_ROOT_DCB ) {
|
|
|
|
FatResetFcb( IrpContext, Fcb );
|
|
|
|
FatMarkFcbCondition( IrpContext, Fcb, FcbGood, FALSE );
|
|
|
|
return;
|
|
}
|
|
|
|
// The first thing we need to do to verify ourselves is
|
|
// locate the dirent on the disk.
|
|
//
|
|
|
|
FatGetDirentFromFcbOrDcb( IrpContext,
|
|
Fcb,
|
|
&Dirent,
|
|
&DirentBcb );
|
|
|
|
//
|
|
// If we couldn't get the dirent, this fcb must be bad (case of
|
|
// enclosing directory shrinking during the time it was ejected).
|
|
//
|
|
|
|
if (DirentBcb == NULL) {
|
|
|
|
FatMarkFcbCondition( IrpContext, Fcb, FcbBad, TRUE );
|
|
return;
|
|
}
|
|
|
|
//
|
|
// We located the dirent for ourselves now make sure it
|
|
// is really ours by comparing the Name and FatFlags.
|
|
// Then for a file we also check the file size.
|
|
//
|
|
// Note that we have to unpin the Bcb before calling FatResetFcb
|
|
// in order to avoid a deadlock in CcUninitializeCacheMap.
|
|
//
|
|
|
|
try {
|
|
|
|
Name.MaximumLength = 16;
|
|
Name.Buffer = &Buffer[0];
|
|
|
|
Fat8dot3ToString( IrpContext, Dirent, FALSE, &Name );
|
|
|
|
//
|
|
// We need to calculate the first cluster 'cause FAT32 splits
|
|
// this field across the dirent.
|
|
//
|
|
|
|
FirstClusterOfFile = Dirent->FirstClusterOfFile;
|
|
|
|
if (FatIsFat32( Fcb->Vcb )) {
|
|
|
|
FirstClusterOfFile += Dirent->FirstClusterOfFileHi << 16;
|
|
}
|
|
|
|
if (!RtlEqualString( &Name, &Fcb->ShortName.Name.Oem, TRUE )
|
|
|
|
||
|
|
|
|
( (NodeType(Fcb) == FAT_NTC_FCB) &&
|
|
(Fcb->Header.FileSize.LowPart != Dirent->FileSize) )
|
|
|
|
||
|
|
|
|
(FirstClusterOfFile != Fcb->FirstClusterOfFile)
|
|
|
|
||
|
|
|
|
(Dirent->Attributes != Fcb->DirentFatFlags) ) {
|
|
|
|
FatMarkFcbCondition( IrpContext, Fcb, FcbBad, TRUE );
|
|
|
|
} else {
|
|
|
|
//
|
|
// We passed. Get the Fcb ready to use again.
|
|
//
|
|
|
|
FatResetFcb( IrpContext, Fcb );
|
|
|
|
FatMarkFcbCondition( IrpContext, Fcb, FcbGood, FALSE );
|
|
}
|
|
|
|
} finally {
|
|
|
|
FatUnpinBcb( IrpContext, DirentBcb );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Internal support routine
|
|
//
|
|
|
|
VOID
|
|
FatQuickVerifyVcb (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
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.
|
|
|
|
--*/
|
|
|
|
{
|
|
//
|
|
// 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( IrpContext->OriginatingIrp,
|
|
Vcb->Vpb->RealDevice );
|
|
|
|
FatRaiseStatus( IrpContext, STATUS_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) &&
|
|
((IrpContext->MajorFunction == IRP_MJ_WRITE) ||
|
|
(IrpContext->MajorFunction == IRP_MJ_SET_INFORMATION) ||
|
|
(IrpContext->MajorFunction == IRP_MJ_SET_EA) ||
|
|
(IrpContext->MajorFunction == IRP_MJ_FLUSH_BUFFERS) ||
|
|
(IrpContext->MajorFunction == IRP_MJ_SET_VOLUME_INFORMATION) ||
|
|
(IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL &&
|
|
IrpContext->MinorFunction == IRP_MN_USER_FS_REQUEST &&
|
|
IoGetCurrentIrpStackLocation(IrpContext->OriginatingIrp)->Parameters.FileSystemControl.FsControlCode ==
|
|
FSCTL_MARK_VOLUME_DIRTY))) {
|
|
|
|
//
|
|
// 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( IrpContext->OriginatingIrp,
|
|
Vcb->Vpb->RealDevice );
|
|
|
|
SetFlag(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME);
|
|
|
|
FatRaiseStatus( IrpContext, STATUS_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( IrpContext->OriginatingIrp,
|
|
Vcb->Vpb->RealDevice );
|
|
|
|
SetFlag(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME);
|
|
|
|
FatRaiseStatus( IrpContext, STATUS_WRONG_VOLUME );
|
|
|
|
break;
|
|
|
|
case VcbBad:
|
|
|
|
DebugTrace(0, Dbg, "The Vcb is bad\n", 0);
|
|
|
|
if (FlagOn( Vcb->VcbState, VCB_STATE_FLAG_VOLUME_DISMOUNTED )) {
|
|
|
|
FatRaiseStatus( IrpContext, STATUS_VOLUME_DISMOUNTED );
|
|
|
|
} else {
|
|
|
|
FatRaiseStatus( IrpContext, STATUS_FILE_INVALID );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
DebugDump("Invalid VcbCondition\n", 0, Vcb);
|
|
FatBugCheck( Vcb->VcbCondition, 0, 0 );
|
|
}
|
|
}
|
|
|
|
NTSTATUS
|
|
FatPerformVerify (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
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;
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PIO_STACK_LOCATION IrpSp;
|
|
|
|
//
|
|
// 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 FatFsdPostRequest( IrpContext, Irp );
|
|
}
|
|
|
|
DebugTrace(0, Dbg, "Verify Required, DeviceObject = %08lx\n", Device);
|
|
|
|
//
|
|
// 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;
|
|
|
|
//
|
|
// 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)) {
|
|
|
|
PFILE_OBJECT FileObject = IoGetCurrentIrpStackLocation(Irp)->FileObject;
|
|
BOOLEAN AllowRawMount;
|
|
|
|
//
|
|
// We will allow Raw to mount this volume if we were doing a
|
|
// a DASD open.
|
|
//
|
|
|
|
if ( (IrpContext->MajorFunction == IRP_MJ_CREATE) &&
|
|
(IrpSp->FileObject->FileName.Length == 0) &&
|
|
(IrpSp->FileObject->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 STATUS_SUCCESS or STATUS_WRONG_VOLUME, exactly.
|
|
//
|
|
// If FatVerifyVolume encountered an error during
|
|
// processing, it will return that error. If we got
|
|
// STATUS_WRONG_VOLUME from the verfy, and our volume
|
|
// is now mounted, commute the status to STATUS_SUCCESS.
|
|
//
|
|
|
|
if ( (Status == STATUS_WRONG_VOLUME) &&
|
|
(Vcb->VcbCondition == VcbGood) ) {
|
|
|
|
Status = STATUS_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)FatAcquireExclusiveGlobal( IrpContext );
|
|
|
|
if ( ((Vcb->VcbCondition == VcbNotMounted) ||
|
|
(Vcb->VcbCondition == VcbBad)) &&
|
|
(Vcb->OpenFileCount == 0) ) {
|
|
|
|
(VOID)FatCheckForDismount( IrpContext, Vcb, FALSE );
|
|
}
|
|
|
|
FatReleaseGlobal( IrpContext );
|
|
|
|
if ((IrpContext->MajorFunction == IRP_MJ_CREATE) &&
|
|
(FileObject->RelatedFileObject == NULL) &&
|
|
((Status == STATUS_SUCCESS) || (Status == STATUS_WRONG_VOLUME))) {
|
|
|
|
Irp->IoStatus.Information = IO_REMOUNT;
|
|
|
|
FatCompleteRequest( IrpContext, Irp, STATUS_REPARSE );
|
|
Status = STATUS_REPARSE;
|
|
Irp = NULL;
|
|
}
|
|
|
|
if ( (Irp != NULL) && !NT_SUCCESS(Status) ) {
|
|
|
|
//
|
|
// Fill in the device object if required.
|
|
//
|
|
|
|
if ( IoIsErrorUserInduced( Status ) ) {
|
|
|
|
IoSetHardErrorOrVerifyDevice( Irp, Device );
|
|
}
|
|
|
|
FatNormalizeAndRaiseStatus( IrpContext, 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 = FatFsdPostRequest( IrpContext, Irp );
|
|
}
|
|
|
|
} except(FatExceptionFilter( IrpContext, 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 = FatProcessException( IrpContext, Irp, GetExceptionCode() );
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
NTSTATUS
|
|
FatMarkVolumeCompletionRoutine(
|
|
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 STATUS_MORE_PROCESSING_REQUIRED;
|
|
}
|
|
|