NTSTATUS
FatCommonClose (
IN PVCB Vcb,
IN PFCB Fcb,
IN PCCB Ccb,
IN TYPE_OF_OPEN TypeOfOpen,
IN BOOLEAN Wait,
IN BOOLEAN TopLevel,
OUT PBOOLEAN VcbDeleted OPTIONAL
)
/*++
Routine Description:
This is the common routine for closing a file/directory called by both
the fsd and fsp threads.
Close is invoked whenever the last reference to a file object is deleted.
Cleanup is invoked when the last handle to a file object is closed, and
is called before close.
The function of close is to completely tear down and remove the fcb/dcb/ccb
structures associated with the file object.
Arguments:
Fcb - Supplies the file to process.
Wait - If this is TRUE we are allowed to block for the Vcb, if FALSE
then we must try to acquire the Vcb anyway.
TopLevel - If this is TRUE this is a top level request.
VcbDeleted - Returns whether the VCB was deleted by this call.
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PDCB ParentDcb;
BOOLEAN RecursiveClose;
BOOLEAN LocalVcbDeleted;
IRP_CONTEXT IrpContext;
PAGED_CODE();
DebugTrace(+1, Dbg, "FatCommonClose...\n", 0);
//
// Initailize the callers variable, if needed.
//
LocalVcbDeleted = FALSE;
if (ARGUMENT_PRESENT( VcbDeleted )) {
*VcbDeleted = LocalVcbDeleted;
}
//
// Special case the unopened file object
//
if (TypeOfOpen == UnopenedFileObject) {
DebugTrace(0, Dbg, "Close unopened file object\n", 0);
Status = STATUS_SUCCESS;
DebugTrace(-1, Dbg, "FatCommonClose -> %08lx\n", Status);
return Status;
}
//
// Set up our stack IrpContext.
//
RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT) );
IrpContext.NodeTypeCode = FAT_NTC_IRP_CONTEXT;
IrpContext.NodeByteSize = sizeof( IrpContext );
IrpContext.MajorFunction = IRP_MJ_CLOSE;
IrpContext.Vcb = Vcb;
if (Wait) {
SetFlag( IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT );
}
//
// Acquire exclusive access to the Vcb and enqueue the irp if we didn't
// get access.
//
#pragma prefast( suppress: 28137, "prefast wants Wait to be a constant, but that's not possible for fastfat" )
if (!ExAcquireResourceExclusiveLite( &Vcb->Resource, Wait )) {
return STATUS_PENDING;
}
//
// The following test makes sure that we don't blow away an Fcb if we
// are trying to do a Supersede/Overwrite open above us. This test
// does not apply for the EA file.
//
if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_CREATE_IN_PROGRESS) &&
Vcb->EaFcb != Fcb) {
ExReleaseResourceLite( &Vcb->Resource );
return STATUS_PENDING;
}
//
// Setting the following flag prevents recursive closes of directory file
// objects, which are handled in a special case loop.
//
if ( FlagOn(Vcb->VcbState, VCB_STATE_FLAG_CLOSE_IN_PROGRESS) ) {
RecursiveClose = TRUE;
} else {
SetFlag(Vcb->VcbState, VCB_STATE_FLAG_CLOSE_IN_PROGRESS);
RecursiveClose = FALSE;
//
// Since we are at the top of the close chain, we need to add
// a reference to the VCB. This will keep it from going away
// on us until we are ready to check for a dismount below.
//
Vcb->OpenFileCount += 1;
}
try {
//
// Case on the type of open that we are trying to close.
//
switch (TypeOfOpen) {
case VirtualVolumeFile:
DebugTrace(0, Dbg, "Close VirtualVolumeFile\n", 0);
//
// Remove this internal, residual open from the count.
//
InterlockedDecrement( (LONG*)&(Vcb->InternalOpenCount) );
InterlockedDecrement( (LONG*)&(Vcb->ResidualOpenCount) );
try_return( Status = STATUS_SUCCESS );
break;
case UserVolumeOpen:
DebugTrace(0, Dbg, "Close UserVolumeOpen\n", 0);
Vcb->DirectAccessOpenCount -= 1;
Vcb->OpenFileCount -= 1;
if (FlagOn(Ccb->Flags, CCB_FLAG_READ_ONLY)) { Vcb->ReadOnlyCount -= 1; }
FatDeleteCcb( &IrpContext, &Ccb );
try_return( Status = STATUS_SUCCESS );
break;
case EaFile:
DebugTrace(0, Dbg, "Close EaFile\n", 0);
//
// Remove this internal, residual open from the count.
//
InterlockedDecrement( (LONG*)&(Vcb->InternalOpenCount) );
InterlockedDecrement( (LONG*)&(Vcb->ResidualOpenCount) );
try_return( Status = STATUS_SUCCESS );
break;
case DirectoryFile:
DebugTrace(0, Dbg, "Close DirectoryFile\n", 0);
InterlockedDecrement( (LONG*)&Fcb->Specific.Dcb.DirectoryFileOpenCount );
//
// Remove this internal open from the count.
//
InterlockedDecrement( (LONG*)&(Vcb->InternalOpenCount) );
//
// If this is the root directory, it is a residual open
// as well.
//
if (NodeType( Fcb ) == FAT_NTC_ROOT_DCB) {
InterlockedDecrement( (LONG*)&(Vcb->ResidualOpenCount) );
}
//
// If this is a recursive close, just return here.
//
if ( RecursiveClose ) {
try_return( Status = STATUS_SUCCESS );
} else {
break;
}
case UserDirectoryOpen:
case UserFileOpen:
DebugTrace(0, Dbg, "Close UserFileOpen/UserDirectoryOpen\n", 0);
//
// Uninitialize the cache map if we no longer need to use it
//
if ((NodeType(Fcb) == FAT_NTC_DCB) &&
IsListEmpty(&Fcb->Specific.Dcb.ParentDcbQueue) &&
(Fcb->OpenCount == 1) &&
(Fcb->Specific.Dcb.DirectoryFile != NULL)) {
PFILE_OBJECT DirectoryFileObject = Fcb->Specific.Dcb.DirectoryFile;
DebugTrace(0, Dbg, "Uninitialize the stream file object\n", 0);
CcUninitializeCacheMap( DirectoryFileObject, NULL, NULL );
//
// Dereference the directory file. This may cause a close
// Irp to be processed, so we need to do this before we destory
// the Fcb.
//
Fcb->Specific.Dcb.DirectoryFile = NULL;
ObDereferenceObject( DirectoryFileObject );
}
Fcb->OpenCount -= 1;
Vcb->OpenFileCount -= 1;
if (FlagOn(Ccb->Flags, CCB_FLAG_READ_ONLY)) { Vcb->ReadOnlyCount -= 1; }
FatDeleteCcb( &IrpContext, &Ccb );
break;
default:
#pragma prefast( suppress: 28159, "if the type of open is unknown, we seriously messed up." )
FatBugCheck( TypeOfOpen, 0, 0 );
}
//
// At this point we've cleaned up any on-disk structure that needs
// to be done, and we can now update the in-memory structures.
// Now if this is an unreferenced FCB or if it is
// an unreferenced DCB (not the root) then we can remove
// the fcb and set our ParentDcb to non null.
//
if (((NodeType(Fcb) == FAT_NTC_FCB) &&
(Fcb->OpenCount == 0))
||
((NodeType(Fcb) == FAT_NTC_DCB) &&
(IsListEmpty(&Fcb->Specific.Dcb.ParentDcbQueue)) &&
(Fcb->OpenCount == 0) &&
(Fcb->Specific.Dcb.DirectoryFileOpenCount == 0))) {
ParentDcb = Fcb->ParentDcb;
SetFlag( Vcb->VcbState, VCB_STATE_FLAG_DELETED_FCB );
FatDeleteFcb( &IrpContext, &Fcb );
//
// Uninitialize our parent's cache map if we no longer need
// to use it.
//
while ((NodeType(ParentDcb) == FAT_NTC_DCB) &&
IsListEmpty(&ParentDcb->Specific.Dcb.ParentDcbQueue) &&
(ParentDcb->OpenCount == 0) &&
(ParentDcb->Specific.Dcb.DirectoryFile != NULL)) {
PFILE_OBJECT DirectoryFileObject;
DirectoryFileObject = ParentDcb->Specific.Dcb.DirectoryFile;
DebugTrace(0, Dbg, "Uninitialize our parent Stream Cache Map\n", 0);
CcUninitializeCacheMap( DirectoryFileObject, NULL, NULL );
ParentDcb->Specific.Dcb.DirectoryFile = NULL;
ObDereferenceObject( DirectoryFileObject );
//
// Now, if the ObDereferenceObject() caused the final close
// to come in, then blow away the Fcb and continue up,
// otherwise wait for Mm to to dereference its file objects
// and stop here..
//
if ( ParentDcb->Specific.Dcb.DirectoryFileOpenCount == 0) {
PDCB CurrentDcb;
CurrentDcb = ParentDcb;
ParentDcb = CurrentDcb->ParentDcb;
SetFlag( Vcb->VcbState, VCB_STATE_FLAG_DELETED_FCB );
FatDeleteFcb( &IrpContext, &CurrentDcb );
} else {
break;
}
}
}
Status = STATUS_SUCCESS;
try_exit: NOTHING;
} finally {
DebugUnwind( FatCommonClose );
//
// We are done processing the close. If we are the top of the close
// chain, see if the VCB can go away. We have biased the open count by
// one, so we need to take that into account.
//
if (!RecursiveClose) {
//
// See if there is only one open left. If so, it is ours. We only want
// to check for a dismount if a dismount is not already in progress.
// We also only do this if the Vcb condition is not VcbGood and the
// caller can handle the VCB going away. This is determined by whether
// they passed in the VcbDeleted argument. This request also needs
// to be top level.
//
if (Vcb->OpenFileCount == 1 &&
Vcb->VcbCondition != VcbGood &&
!FlagOn( Vcb->VcbState, VCB_STATE_FLAG_DISMOUNT_IN_PROGRESS ) &&
ARGUMENT_PRESENT( VcbDeleted ) &&
TopLevel) {
//
// We need the global lock, which must be acquired before the
// VCB. Since we already have the VCB, we have to drop and
// reaquire here. Note that we always want to wait from this
// point on. Note that the VCB cannot go away, since we have
// biased the open file count.
//
FatReleaseVcb( &IrpContext,
Vcb );
SetFlag( IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT );
#pragma prefast( suppress: 28137, "prefast wants the wait parameter in this macro expansion to be a constant, unfortunately this is not possible" )
FatAcquireExclusiveGlobal( &IrpContext );
FatAcquireExclusiveVcb( &IrpContext,
Vcb );
//
// We have our locks in the correct order. Remove our
// extra open and check for a dismount. Note that if
// something changed while we dropped the lock, it will
// not matter, since the dismount code does the correct
// checks to make sure the volume can really go away.
//
Vcb->OpenFileCount -= 1;
LocalVcbDeleted = FatCheckForDismount( &IrpContext,
Vcb,
FALSE );
FatReleaseGlobal( &IrpContext );
//
// Let the caller know what happened, if they want this information.
//
if (ARGUMENT_PRESENT( VcbDeleted )) {
*VcbDeleted = LocalVcbDeleted;
}
} else {
//
// The volume cannot go away now. Just remove our extra reference.
//
Vcb->OpenFileCount -= 1;
}
//
// If the VCB is still around, clear our recursion flag.
//
if (!LocalVcbDeleted) {
ClearFlag( Vcb->VcbState, VCB_STATE_FLAG_CLOSE_IN_PROGRESS );
}
}
//
// Only release the VCB if it did not go away.
//
if (!LocalVcbDeleted) {
FatReleaseVcb( &IrpContext, Vcb );
}
DebugTrace(-1, Dbg, "FatCommonClose -> %08lx\n", Status);
}
return Status;
}
__drv_mustHoldCriticalRegion
NTSTATUS
FatCommonShutdown (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for shutdown called by both the fsd and
fsp threads.
Arguments:
Irp - Supplies the Irp being processed
Return Value:
NTSTATUS - The return status for the operation
--*/
{
KEVENT Event;
PLIST_ENTRY Links;
PVCB Vcb;
PIRP NewIrp;
IO_STATUS_BLOCK Iosb;
BOOLEAN VcbDeleted;
PAGED_CODE();
//
// Make sure we don't get any pop-ups, and write everything through.
//
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS |
IRP_CONTEXT_FLAG_WRITE_THROUGH);
//
// Initialize an event for doing calls down to
// our target device objects.
//
KeInitializeEvent( &Event, NotificationEvent, FALSE );
//
// Indicate that shutdown has started. This is used in FatFspClose.
//
FatData.ShutdownStarted = TRUE;
//
// Get everyone else out of the way
//
ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
#pragma prefast( push )
#pragma prefast( disable: 28137, "prefast wants the wait to be a constant, but that isn't possible for the way fastfat is designed" )
#pragma prefast( disable: 28193, "this will always wait" )
(VOID) FatAcquireExclusiveGlobal( IrpContext );
#pragma prefast( pop )
try {
//
// For every volume that is mounted we will flush the
// volume and then shutdown the target device objects.
//
Links = FatData.VcbQueue.Flink;
while (Links != &FatData.VcbQueue) {
Vcb = CONTAINING_RECORD(Links, VCB, VcbLinks);
Links = Links->Flink;
//
// If we have already been called before for this volume
// (and yes this does happen), skip this volume as no writes
// have been allowed since the first shutdown.
//
if ( FlagOn( Vcb->VcbState, VCB_STATE_FLAG_SHUTDOWN) ||
(Vcb->VcbCondition != VcbGood) ) {
continue;
}
FatAcquireExclusiveVolume( IrpContext, Vcb );
try {
(VOID)FatFlushVolume( IrpContext, Vcb, Flush );
//
// The volume is now clean, note it. We purge the
// volume file cache map before marking the volume
// clean incase there is a stale Bpb in the cache.
//
if (!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY)) {
CcPurgeCacheSection( &Vcb->SectionObjectPointers,
NULL,
0,
FALSE );
FatMarkVolume( IrpContext, Vcb, VolumeClean );
}
} except( EXCEPTION_EXECUTE_HANDLER ) {
FatResetExceptionState( IrpContext );
}
//
// Sometimes we take an excepion while flushing the volume, such
// as when autoconv has converted the volume and is rebooting.
// Even in that case we want to send the shutdown irp to the
// target device so it can know to flush its cache, if it has one.
//
try {
NewIrp = IoBuildSynchronousFsdRequest( IRP_MJ_SHUTDOWN,
Vcb->TargetDeviceObject,
NULL,
0,
NULL,
&Event,
&Iosb );
if (NewIrp != NULL) {
if (NT_SUCCESS(IoCallDriver( Vcb->TargetDeviceObject, NewIrp ))) {
(VOID) KeWaitForSingleObject( &Event,
Executive,
KernelMode,
FALSE,
NULL );
KeClearEvent( &Event );
}
}
} except( EXCEPTION_EXECUTE_HANDLER ) {
FatResetExceptionState( IrpContext );
}
SetFlag( Vcb->VcbState, VCB_STATE_FLAG_SHUTDOWN );
//
// Attempt to punch the volume down.
//
VcbDeleted = FatCheckForDismount( IrpContext,
Vcb,
FALSE );
if (!VcbDeleted) {
#pragma prefast( suppress:28107, "prefast is having trouble figuring out that Vcb is acquired" )
FatReleaseVolume( IrpContext, Vcb );
}
}
} finally {
FatReleaseGlobal( IrpContext );
//
// Unregister the file system.
//
IoUnregisterFileSystem( FatDiskFileSystemDeviceObject);
IoUnregisterFileSystem( FatCdromFileSystemDeviceObject);
IoDeleteDevice( FatDiskFileSystemDeviceObject);
IoDeleteDevice( FatCdromFileSystemDeviceObject);
FatCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
}
//
// And return to our caller
//
DebugTrace(-1, Dbg, "FatFsdShutdown -> STATUS_SUCCESS\n", 0);
return STATUS_SUCCESS;
}
NTSTATUS
FatCommonClose (
IN PVCB Vcb,
IN PFCB Fcb,
IN PCCB Ccb,
IN TYPE_OF_OPEN TypeOfOpen,
IN BOOLEAN Wait,
OUT PBOOLEAN VcbDeleted OPTIONAL
)
/*++
Routine Description:
This is the common routine for closing a file/directory called by both
the fsd and fsp threads.
Close is invoked whenever the last reference to a file object is deleted.
Cleanup is invoked when the last handle to a file object is closed, and
is called before close.
The function of close is to completely tear down and remove the fcb/dcb/ccb
structures associated with the file object.
Arguments:
Fcb - Supplies the file to process.
Wait - If this is TRUE we are allowed to block for the Vcb, if FALSE
then we must try to acquire the Vcb anyway.
VcbDeleted - Returns whether the VCB was deleted by this call.
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PDCB ParentDcb;
BOOLEAN RecursiveClose;
BOOLEAN LocalVcbDeleted;
IRP_CONTEXT IrpContext;
#if __NDAS_FAT_SECONDARY__
BOOLEAN volDoResourceAcquired = FALSE;
BOOLEAN send2Primary = FALSE;
BOOLEAN volDoCcb = FALSE;
_U64 primaryFileHandle;
PVOLUME_DEVICE_OBJECT volDo = CONTAINING_RECORD( Vcb, VOLUME_DEVICE_OBJECT, Vcb );
BOOLEAN volDoSessionResourceAcquired = FALSE;
PSECONDARY_REQUEST secondaryRequest = NULL;
PNDFS_REQUEST_HEADER ndfsRequestHeader;
PNDFS_WINXP_REQUEST_HEADER ndfsWinxpRequestHeader;
PNDFS_WINXP_REPLY_HEADER ndfsWinxpReplytHeader;
LARGE_INTEGER timeOut;
#endif
PAGED_CODE();
DebugTrace(+1, Dbg, "FatCommonClose...\n", 0);
//
// Initailize the callers variable, if needed.
//
LocalVcbDeleted = FALSE;
if (ARGUMENT_PRESENT( VcbDeleted )) {
*VcbDeleted = LocalVcbDeleted;
}
//
// Special case the unopened file object
//
if (TypeOfOpen == UnopenedFileObject) {
DebugTrace(0, Dbg, "Close unopened file object\n", 0);
Status = STATUS_SUCCESS;
DebugTrace(-1, Dbg, "FatCommonClose -> %08lx\n", Status);
return Status;
}
//
// Set up our stack IrpContext.
//
RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT) );
IrpContext.NodeTypeCode = FAT_NTC_IRP_CONTEXT;
IrpContext.NodeByteSize = sizeof( IrpContext );
IrpContext.MajorFunction = IRP_MJ_CLOSE;
IrpContext.Vcb = Vcb;
if (Wait) {
SetFlag( IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT );
}
#if __NDAS_FAT_SECONDARY__
if (Fcb && FlagOn(Fcb->NdasFatFlags, ND_FAT_FCB_FLAG_SECONDARY))
SetFlag( IrpContext.NdasFatFlags, NDAS_FAT_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT );
if (Fcb && FlagOn(Fcb->NdasFatFlags, ND_FAT_FCB_FLAG_SECONDARY)) {
if (!FlagOn(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT)) {
return STATUS_PENDING;
}
volDoResourceAcquired =
SecondaryAcquireResourceSharedStarveExclusiveLite( &IrpContext,
&volDo->Resource,
BooleanFlagOn(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT) );
if (volDoResourceAcquired == FALSE) {
ASSERT( FlagOn(volDo->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ); // It's not always garented continue;
return STATUS_PENDING;
}
}
if (volDo->NetdiskEnableMode == NETDISK_SECONDARY &&
!FlagOn(volDo->NetdiskPartitionInformation.Flags, NETDISK_PARTITION_INFORMATION_FLAG_INDIRECT)) {
if (TypeOfOpen == VirtualVolumeFile || TypeOfOpen == DirectoryFile) {
SetFlag( IrpContext.NdasFatFlags, NDAS_FAT_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT );
}
}
#endif
//
// Acquire exclusive access to the Vcb and enqueue the irp if we didn't
// get access.
//
#if __NDAS_FAT_SECONDARY__
if (!(FlagOn(IrpContext.NdasFatFlags, NDAS_FAT_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT) ?
ExAcquireResourceExclusiveLite( &Vcb->SecondaryResource, Wait ) : ExAcquireResourceExclusiveLite( &Vcb->Resource, Wait ))) {
if (volDoResourceAcquired) {
ASSERT( ExIsResourceAcquiredSharedLite(&volDo->Resource) );
SecondaryReleaseResourceLite( NULL, &volDo->Resource );
}
return STATUS_PENDING;
}
#else
if (!ExAcquireResourceExclusiveLite( &Vcb->Resource, Wait )) {
return STATUS_PENDING;
}
#endif
//
// The following test makes sure that we don't blow away an Fcb if we
// are trying to do a Supersede/Overwrite open above us. This test
// does not apply for the EA file.
//
if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_CREATE_IN_PROGRESS) &&
Vcb->EaFcb != Fcb) {
#if __NDAS_FAT_SECONDARY__
if (FlagOn(IrpContext.NdasFatFlags, NDAS_FAT_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT))
ExReleaseResourceLite( &Vcb->SecondaryResource );
else
ExReleaseResourceLite( &Vcb->Resource );
if (volDoResourceAcquired) {
ASSERT( ExIsResourceAcquiredSharedLite(&volDo->Resource) );
SecondaryReleaseResourceLite( NULL, &volDo->Resource );
}
#else
ExReleaseResourceLite( &Vcb->Resource );
#endif
return STATUS_PENDING;
}
//
// Setting the following flag prevents recursive closes of directory file
// objects, which are handled in a special case loop.
//
if ( FlagOn(Vcb->VcbState, VCB_STATE_FLAG_CLOSE_IN_PROGRESS) ) {
RecursiveClose = TRUE;
} else {
SetFlag(Vcb->VcbState, VCB_STATE_FLAG_CLOSE_IN_PROGRESS);
RecursiveClose = FALSE;
//
// Since we are at the top of the close chain, we need to add
// a reference to the VCB. This will keep it from going away
// on us until we are ready to check for a dismount below.
//
Vcb->OpenFileCount += 1;
}
try {
//
// Case on the type of open that we are trying to close.
//
switch (TypeOfOpen) {
case VirtualVolumeFile:
DebugTrace(0, Dbg, "Close VirtualVolumeFile\n", 0);
//
// Remove this internal, residual open from the count.
//
InterlockedDecrement( &(Vcb->InternalOpenCount) );
InterlockedDecrement( &(Vcb->ResidualOpenCount) );
try_return( Status = STATUS_SUCCESS );
break;
case UserVolumeOpen:
DebugTrace(0, Dbg, "Close UserVolumeOpen\n", 0);
#if __NDAS_FAT_SECONDARY__
if (Fcb && FlagOn(Fcb->NdasFatFlags, ND_FAT_FCB_FLAG_SECONDARY)) {
volDoCcb = TRUE;
if (FlagOn(Ccb->NdasFatFlags, ND_FAT_CCB_FLAG_UNOPENED)) {
if ( FlagOn(Ccb->NdasFatFlags, ND_FAT_CCB_FLAG_CORRUPTED) )
Fcb->CorruptedCcbCloseCount --;
send2Primary = FALSE;
} else
send2Primary = TRUE;
primaryFileHandle = Ccb->PrimaryFileHandle;
ExAcquireFastMutex( &volDo->Secondary->RecoveryCcbQMutex );
RemoveEntryList( &Ccb->ListEntry );
ExReleaseFastMutex( &volDo->Secondary->RecoveryCcbQMutex );
InitializeListHead( &Ccb->ListEntry );
Ccb->FileObject = NULL;
if (Ccb->Buffer)
ExFreePool( Ccb->Buffer );
Ccb->FileObject = NULL;
InterlockedDecrement( &Vcb->SecondaryOpenFileCount );
} else {
Vcb->DirectAccessOpenCount -= 1;
Vcb->OpenFileCount -= 1;
if (FlagOn(Ccb->Flags, CCB_FLAG_READ_ONLY)) { Vcb->ReadOnlyCount -= 1; }
}
if (FlagOn(Ccb->NdasFatFlags, ND_FAT_CCB_FLAG_OPEN_BY_PRIMARY_SESSION)) {
InterlockedDecrement( &Vcb->PrimaryOpenFileCount );
}
FatDeleteCcb( &IrpContext, &Ccb );
if (Fcb && FlagOn(Fcb->NdasFatFlags, ND_FAT_FCB_FLAG_SECONDARY)) {
InterlockedDecrement( &Fcb->OpenCount );
if (Fcb->OpenCount == 0) {
ExAcquireFastMutex( &volDo->Secondary->FcbQMutex );
RemoveEntryList( &Fcb->ListEntry );
InitializeListHead( &Fcb->ListEntry );
ExReleaseFastMutex( &volDo->Secondary->FcbQMutex );
Fcb->Header.NodeTypeCode = FAT_NTC_FCB;
FatDeleteFcb( &IrpContext, &Fcb );
Secondary_Dereference( volDo->Secondary );
}
} else {
try_return( Status = STATUS_SUCCESS );
}
#else
Vcb->DirectAccessOpenCount -= 1;
Vcb->OpenFileCount -= 1;
if (FlagOn(Ccb->Flags, CCB_FLAG_READ_ONLY)) { Vcb->ReadOnlyCount -= 1; }
FatDeleteCcb( &IrpContext, &Ccb );
try_return( Status = STATUS_SUCCESS );
#endif
break;
case EaFile:
DebugTrace(0, Dbg, "Close EaFile\n", 0);
//
// Remove this internal, residual open from the count.
//
InterlockedDecrement( &(Vcb->InternalOpenCount) );
InterlockedDecrement( &(Vcb->ResidualOpenCount) );
try_return( Status = STATUS_SUCCESS );
break;
case DirectoryFile:
DebugTrace(0, Dbg, "Close DirectoryFile\n", 0);
InterlockedDecrement( &Fcb->Specific.Dcb.DirectoryFileOpenCount );
//
// Remove this internal open from the count.
//
InterlockedDecrement( &(Vcb->InternalOpenCount) );
//
// If this is the root directory, it is a residual open
// as well.
//
if (NodeType( Fcb ) == FAT_NTC_ROOT_DCB) {
InterlockedDecrement( &(Vcb->ResidualOpenCount) );
}
//
// If this is a recursive close, just return here.
//
if ( RecursiveClose ) {
try_return( Status = STATUS_SUCCESS );
} else {
break;
}
case UserDirectoryOpen:
case UserFileOpen:
DebugTrace(0, Dbg, "Close UserFileOpen/UserDirectoryOpen\n", 0);
//
// Uninitialize the cache map if we no longer need to use it
//
if ((NodeType(Fcb) == FAT_NTC_DCB) &&
IsListEmpty(&Fcb->Specific.Dcb.ParentDcbQueue) &&
(Fcb->OpenCount == 1) &&
(Fcb->Specific.Dcb.DirectoryFile != NULL)) {
PFILE_OBJECT DirectoryFileObject = Fcb->Specific.Dcb.DirectoryFile;
DebugTrace(0, Dbg, "Uninitialize the stream file object\n", 0);
CcUninitializeCacheMap( DirectoryFileObject, NULL, NULL );
//
// Dereference the directory file. This may cause a close
// Irp to be processed, so we need to do this before we destory
// the Fcb.
//
Fcb->Specific.Dcb.DirectoryFile = NULL;
ObDereferenceObject( DirectoryFileObject );
}
#if __NDAS_FAT__
if (TypeOfOpen == UserFileOpen) {
ExAcquireFastMutex( &Fcb->NonPaged->CcbQMutex );
Ccb->FileObject = NULL;
Ccb->Fcb = NULL;
RemoveEntryList( &Ccb->FcbListEntry );
InitializeListHead( &Ccb->FcbListEntry );
ExReleaseFastMutex( &Fcb->NonPaged->CcbQMutex );
}
#endif
Fcb->OpenCount -= 1;
#if __NDAS_FAT_SECONDARY__
if (Fcb && FlagOn(Fcb->NdasFatFlags, ND_FAT_FCB_FLAG_SECONDARY)) {
volDoCcb = TRUE;
if (FlagOn(Ccb->NdasFatFlags, ND_FAT_CCB_FLAG_UNOPENED)) {
if ( FlagOn(Ccb->NdasFatFlags, ND_FAT_CCB_FLAG_CORRUPTED) )
Fcb->CorruptedCcbCloseCount --;
send2Primary = FALSE;
} else
send2Primary = TRUE;
primaryFileHandle = Ccb->PrimaryFileHandle;
ExAcquireFastMutex( &volDo->Secondary->RecoveryCcbQMutex );
RemoveEntryList( &Ccb->ListEntry );
ExReleaseFastMutex( &volDo->Secondary->RecoveryCcbQMutex );
InitializeListHead( &Ccb->ListEntry );
Ccb->FileObject = NULL;
if (Ccb->Buffer)
ExFreePool( Ccb->Buffer );
InterlockedDecrement( &Vcb->SecondaryOpenFileCount );
Ccb->FileObject = NULL;
} else {
Vcb->OpenFileCount -= 1;
if (FlagOn(Ccb->Flags, CCB_FLAG_READ_ONLY)) { Vcb->ReadOnlyCount -= 1; }
}
if (FlagOn(Ccb->NdasFatFlags, ND_FAT_CCB_FLAG_OPEN_BY_PRIMARY_SESSION)) {
InterlockedDecrement( &Vcb->PrimaryOpenFileCount );
}
FatDeleteCcb( &IrpContext, &Ccb );
if (Fcb && FlagOn(Fcb->NdasFatFlags, ND_FAT_FCB_FLAG_SECONDARY)) {
if (Fcb->OpenCount == 0) {
ExAcquireFastMutex( &volDo->Secondary->FcbQMutex );
RemoveEntryList( &Fcb->ListEntry );
InitializeListHead( &Fcb->ListEntry );
ExReleaseFastMutex( &volDo->Secondary->FcbQMutex );
Fcb->Header.NodeTypeCode = FAT_NTC_FCB;
FatDeleteFcb( &IrpContext, &Fcb );
Secondary_Dereference( volDo->Secondary );
}
}
#else
Fcb->OpenCount -= 1;
Vcb->OpenFileCount -= 1;
if (FlagOn(Ccb->Flags, CCB_FLAG_READ_ONLY)) { Vcb->ReadOnlyCount -= 1; }
FatDeleteCcb( &IrpContext, &Ccb );
#endif
break;
default:
FatBugCheck( TypeOfOpen, 0, 0 );
}
#if __NDAS_FAT_SECONDARY__
if (send2Primary) {
Status = STATUS_SUCCESS;
volDoSessionResourceAcquired
= SecondaryAcquireResourceExclusiveLite( &IrpContext,
&volDo->SessionResource,
BooleanFlagOn(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT) );
if (FlagOn(volDo->Secondary->Thread.Flags, SECONDARY_THREAD_FLAG_REMOTE_DISCONNECTED) ||
FlagOn(volDo->Secondary->Flags, SECONDARY_FLAG_RECONNECTING)) {
Status = STATUS_SUCCESS;
leave;
}
secondaryRequest = AllocateWinxpSecondaryRequest( volDo->Secondary, IRP_MJ_CLOSE, 0 );
if (secondaryRequest == NULL) {
ASSERT( FALSE );
leave;
}
ndfsRequestHeader = &secondaryRequest->NdfsRequestHeader;
INITIALIZE_NDFS_REQUEST_HEADER( ndfsRequestHeader, NDFS_COMMAND_EXECUTE, volDo->Secondary, IRP_MJ_CLOSE, 0 );
ndfsWinxpRequestHeader = (PNDFS_WINXP_REQUEST_HEADER)(ndfsRequestHeader+1);
ASSERT( ndfsWinxpRequestHeader == (PNDFS_WINXP_REQUEST_HEADER)secondaryRequest->NdfsRequestData );
//ndfsWinxpRequestHeader->IrpTag = (_U32)Fcb;
ndfsWinxpRequestHeader->IrpMajorFunction = IRP_MJ_CLOSE;
ndfsWinxpRequestHeader->IrpMinorFunction = 0;
ndfsWinxpRequestHeader->FileHandle = primaryFileHandle;
ndfsWinxpRequestHeader->IrpFlags = 0;
ndfsWinxpRequestHeader->IrpSpFlags = 0;
secondaryRequest->RequestType = SECONDARY_REQ_SEND_MESSAGE;
QueueingSecondaryRequest( volDo->Secondary, secondaryRequest );
timeOut.QuadPart = -NDASFAT_TIME_OUT;
Status = KeWaitForSingleObject( &secondaryRequest->CompleteEvent, Executive, KernelMode, FALSE, &timeOut );
KeClearEvent( &secondaryRequest->CompleteEvent );
if (Status != STATUS_SUCCESS) {
ASSERT( NDASFAT_BUG );
}
if (secondaryRequest->ExecuteStatus == STATUS_SUCCESS) {
ndfsWinxpReplytHeader = (PNDFS_WINXP_REPLY_HEADER)secondaryRequest->NdfsReplyData;
ASSERT( ndfsWinxpReplytHeader->Status == STATUS_SUCCESS );
leave;
}
ASSERT( secondaryRequest->ExecuteStatus != STATUS_SUCCESS );
}
if (volDoCcb == TRUE) {
Status = STATUS_SUCCESS;
leave;
}
#endif
//
// At this point we've cleaned up any on-disk structure that needs
// to be done, and we can now update the in-memory structures.
// Now if this is an unreferenced FCB or if it is
// an unreferenced DCB (not the root) then we can remove
// the fcb and set our ParentDcb to non null.
//
if (((NodeType(Fcb) == FAT_NTC_FCB) &&
(Fcb->OpenCount == 0))
||
((NodeType(Fcb) == FAT_NTC_DCB) &&
(IsListEmpty(&Fcb->Specific.Dcb.ParentDcbQueue)) &&
(Fcb->OpenCount == 0) &&
(Fcb->Specific.Dcb.DirectoryFileOpenCount == 0))) {
ParentDcb = Fcb->ParentDcb;
SetFlag( Vcb->VcbState, VCB_STATE_FLAG_DELETED_FCB );
FatDeleteFcb( &IrpContext, &Fcb );
//
// Uninitialize our parent's cache map if we no longer need
// to use it.
//
while ((NodeType(ParentDcb) == FAT_NTC_DCB) &&
IsListEmpty(&ParentDcb->Specific.Dcb.ParentDcbQueue) &&
(ParentDcb->OpenCount == 0) &&
(ParentDcb->Specific.Dcb.DirectoryFile != NULL)) {
PFILE_OBJECT DirectoryFileObject;
DirectoryFileObject = ParentDcb->Specific.Dcb.DirectoryFile;
DebugTrace(0, Dbg, "Uninitialize our parent Stream Cache Map\n", 0);
CcUninitializeCacheMap( DirectoryFileObject, NULL, NULL );
ParentDcb->Specific.Dcb.DirectoryFile = NULL;
ObDereferenceObject( DirectoryFileObject );
//
// Now, if the ObDereferenceObject() caused the final close
// to come in, then blow away the Fcb and continue up,
// otherwise wait for Mm to to dereference its file objects
// and stop here..
//
if ( ParentDcb->Specific.Dcb.DirectoryFileOpenCount == 0) {
PDCB CurrentDcb;
CurrentDcb = ParentDcb;
ParentDcb = CurrentDcb->ParentDcb;
SetFlag( Vcb->VcbState, VCB_STATE_FLAG_DELETED_FCB );
FatDeleteFcb( &IrpContext, &CurrentDcb );
} else {
break;
}
}
}
Status = STATUS_SUCCESS;
try_exit: NOTHING;
} finally {
DebugUnwind( FatCommonClose );
#if __NDAS_FAT_SECONDARY__
if (secondaryRequest)
DereferenceSecondaryRequest( secondaryRequest );
if (volDoSessionResourceAcquired) {
SecondaryReleaseResourceLite( &IrpContext, &volDo->SessionResource );
}
if (volDoResourceAcquired) {
ASSERT( ExIsResourceAcquiredSharedLite(&volDo->Resource) );
SecondaryReleaseResourceLite( NULL, &volDo->Resource );
}
#endif
//
// We are done processing the close. If we are the top of the close
// chain, see if the VCB can go away. We have biased the open count by
// one, so we need to take that into account.
//
if (!RecursiveClose) {
//
// See if there is only one open left. If so, it is ours. We only want
// to check for a dismount if a dismount is not already in progress.
// We also only do this if the caller can handle the VCB going away.
// This is determined by whether they passed in the VcbDeleted argument.
//
if (Vcb->OpenFileCount == 1 &&
!FlagOn( Vcb->VcbState, VCB_STATE_FLAG_DISMOUNT_IN_PROGRESS )
&& ARGUMENT_PRESENT( VcbDeleted )) {
//
// We need the global lock, which must be acquired before the
// VCB. Since we already have the VCB, we have to drop and
// reaquire here. Note that we always want to wait from this
// point on. Note that the VCB cannot go away, since we have
// biased the open file count.
//
FatReleaseVcb( &IrpContext,
Vcb );
SetFlag( IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT );
FatAcquireExclusiveGlobal( &IrpContext );
FatAcquireExclusiveVcb( &IrpContext,
Vcb );
//
// We have our locks in the correct order. Remove our
// extra open and check for a dismount. Note that if
// something changed while we dropped the lock, it will
// not matter, since the dismount code does the correct
// checks to make sure the volume can really go away.
//
Vcb->OpenFileCount -= 1;
LocalVcbDeleted = FatCheckForDismount( &IrpContext,
Vcb,
FALSE );
FatReleaseGlobal( &IrpContext );
//
// Let the caller know what happened, if they want this information.
//
if (ARGUMENT_PRESENT( VcbDeleted )) {
*VcbDeleted = LocalVcbDeleted;
}
} else {
//
// The volume cannot go away now. Just remove our extra reference.
//
Vcb->OpenFileCount -= 1;
}
//
// If the VCB is still around, clear our recursion flag.
//
if (!LocalVcbDeleted) {
ClearFlag( Vcb->VcbState, VCB_STATE_FLAG_CLOSE_IN_PROGRESS );
}
}
//
// Only release the VCB if it did not go away.
//
if (!LocalVcbDeleted) {
FatReleaseVcb( &IrpContext, Vcb );
}
DebugTrace(-1, Dbg, "FatCommonClose -> %08lx\n", Status);
}
return Status;
}
NTSTATUS
FatPnpRemove (
PIRP_CONTEXT IrpContext,
PIRP Irp,
PVCB Vcb
)
/*++
Routine Description:
This routine handles the PnP remove operation. This is our notification
that the underlying storage device for the volume we have is gone, and
an excellent indication that the volume will never reappear. The filesystem
is responsible for initiation or completion of the dismount.
Arguments:
Irp - Supplies the Irp to process
Vcb - Supplies the volume being removed.
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
KEVENT Event;
BOOLEAN VcbDeleted;
//
// REMOVE - a storage device is now gone. We either got
// QUERY'd and said yes OR got a SURPRISE OR a storage
// stack failed to spin back up from a sleep/stop state
// (the only case in which this will be the first warning).
//
// Note that it is entirely unlikely that we will be around
// for a REMOVE in the first two cases, as we try to intiate
// dismount.
//
//
// Acquire the global resource so that we can try to vaporize
// the volume, and the vcb resource itself.
//
FatAcquireExclusiveGlobal( IrpContext );
FatAcquireExclusiveVcb( IrpContext, Vcb );
//
// The device will be going away. Remove our lock (benign
// if we never had it).
//
(VOID) FatUnlockVolumeInternal( IrpContext, Vcb, NULL );
//
// We need to pass this down before starting the dismount, which
// could disconnect us immediately from the stack.
//
//
// Get the next stack location, and copy over the stack location
//
IoCopyCurrentIrpStackLocationToNext( Irp );
//
// Set up the completion routine
//
KeInitializeEvent( &Event, NotificationEvent, FALSE );
IoSetCompletionRoutine( Irp,
FatPnpCompletionRoutine,
&Event,
TRUE,
TRUE,
TRUE );
//
// Send the request and wait.
//
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
if (Status == STATUS_PENDING) {
KeWaitForSingleObject( &Event,
Executive,
KernelMode,
FALSE,
NULL );
Status = Irp->IoStatus.Status;
}
try {
//
// Knock as many files down for this volume as we can.
//
FatFlushAndCleanVolume( IrpContext, Irp, Vcb, NoFlush );
//
// Now make our dismount happen. This may not vaporize the
// Vcb, of course, since there could be any number of handles
// outstanding if we were not preceeded by a QUERY.
//
// PnP will take care of disconnecting this stack if we
// couldn't get off of it immediately.
//
VcbDeleted = FatCheckForDismount( IrpContext, Vcb, TRUE );
} finally {
//
// Release the Vcb if it could still remain.
//
if (!VcbDeleted) {
FatReleaseVcb( IrpContext, Vcb );
}
FatReleaseGlobal( IrpContext );
}
//
// Cleanup our IrpContext and complete the IRP.
//
FatCompleteRequest( IrpContext, Irp, Status );
return Status;
}
NTSTATUS
FatPnpSurpriseRemove (
PIRP_CONTEXT IrpContext,
PIRP Irp,
PVCB Vcb
)
/*++
Routine Description:
This routine handles the PnP surprise remove operation. This is another
type of notification that the underlying storage device for the volume we
have is gone, and is excellent indication that the volume will never reappear.
The filesystem is responsible for initiation or completion the dismount.
For the most part, only "real" drivers care about the distinction of a
surprise remove, which is a result of our noticing that a user (usually)
physically reached into the machine and pulled something out.
Surprise will be followed by a Remove when all references have been shut down.
Arguments:
Irp - Supplies the Irp to process
Vcb - Supplies the volume being removed.
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
KEVENT Event;
BOOLEAN VcbDeleted;
//
// SURPRISE - a device was physically yanked away without
// any warning. This means external forces.
//
FatAcquireExclusiveGlobal( IrpContext );
FatAcquireExclusiveVcb( IrpContext, Vcb );
//
// We need to pass this down before starting the dismount, which
// could disconnect us immediately from the stack.
//
//
// Get the next stack location, and copy over the stack location
//
IoCopyCurrentIrpStackLocationToNext( Irp );
//
// Set up the completion routine
//
KeInitializeEvent( &Event, NotificationEvent, FALSE );
IoSetCompletionRoutine( Irp,
FatPnpCompletionRoutine,
&Event,
TRUE,
TRUE,
TRUE );
//
// Send the request and wait.
//
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
if (Status == STATUS_PENDING) {
KeWaitForSingleObject( &Event,
Executive,
KernelMode,
FALSE,
NULL );
Status = Irp->IoStatus.Status;
}
try {
//
// Knock as many files down for this volume as we can.
//
FatFlushAndCleanVolume( IrpContext, Irp, Vcb, NoFlush );
//
// Now make our dismount happen. This may not vaporize the
// Vcb, of course, since there could be any number of handles
// outstanding since this is an out of band notification.
//
VcbDeleted = FatCheckForDismount( IrpContext, Vcb, TRUE );
} finally {
//
// Release the Vcb if it could still remain.
//
if (!VcbDeleted) {
FatReleaseVcb( IrpContext, Vcb );
}
FatReleaseGlobal( IrpContext );
}
//
// Cleanup our IrpContext and complete the IRP.
//
FatCompleteRequest( IrpContext, Irp, Status );
return Status;
}
NTSTATUS
FatPnpQueryRemove (
PIRP_CONTEXT IrpContext,
PIRP Irp,
PVCB Vcb
)
/*++
Routine Description:
This routine handles the PnP query remove operation. The filesystem
is responsible for answering whether there are any reasons it sees
that the volume can not go away (and the device removed). Initiation
of the dismount begins when we answer yes to this question.
Query will be followed by a Cancel or Remove.
Arguments:
Irp - Supplies the Irp to process
Vcb - Supplies the volume being queried.
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
KEVENT Event;
BOOLEAN VcbDeleted = FALSE;
BOOLEAN GlobalHeld = FALSE;
//
// Having said yes to a QUERY, any communication with the
// underlying storage stack is undefined (and may block)
// until the bounding CANCEL or REMOVE is sent.
//
//
// Acquire the global resource so that we can try to vaporize
// the volume, and the vcb resource itself.
//
FatAcquireExclusiveVcb( IrpContext, Vcb );
try {
Status = FatLockVolumeInternal( IrpContext, Vcb, NULL );
//
// Reacquire the resources in the right order.
//
FatReleaseVcb( IrpContext, Vcb );
FatAcquireExclusiveGlobal( IrpContext );
GlobalHeld = TRUE;
FatAcquireExclusiveVcb( IrpContext, Vcb );
if (NT_SUCCESS( Status )) {
//
// With the volume held locked, note that we must finalize as much
// as possible right now.
//
FatFlushAndCleanVolume( IrpContext, Irp, Vcb, Flush );
//
// We need to pass this down before starting the dismount, which
// could disconnect us immediately from the stack.
//
//
// Get the next stack location, and copy over the stack location
//
IoCopyCurrentIrpStackLocationToNext( Irp );
//
// Set up the completion routine
//
KeInitializeEvent( &Event, NotificationEvent, FALSE );
IoSetCompletionRoutine( Irp,
FatPnpCompletionRoutine,
&Event,
TRUE,
TRUE,
TRUE );
//
// Send the request and wait.
//
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
if (Status == STATUS_PENDING) {
KeWaitForSingleObject( &Event,
Executive,
KernelMode,
FALSE,
NULL );
Status = Irp->IoStatus.Status;
}
//
// Now if no one below us failed already, initiate the dismount
// on this volume, make it go away. PnP needs to see our internal
// streams close and drop their references to the target device.
//
// Since we were able to lock the volume, we are guaranteed to
// move this volume into dismount state and disconnect it from
// the underlying storage stack. The force on our part is actually
// unnecesary, though complete.
//
// What is not strictly guaranteed, though, is that the closes
// for the metadata streams take effect synchronously underneath
// of this call. This would leave references on the target device
// even though we are disconnected!
//
if (NT_SUCCESS( Status )) {
VcbDeleted = FatCheckForDismount( IrpContext, Vcb, TRUE );
ASSERT( VcbDeleted || Vcb->VcbCondition == VcbBad );
}
}
} finally {
//
// Release the Vcb if it could still remain.
//
if (!VcbDeleted) {
FatReleaseVcb( IrpContext, Vcb );
}
if (GlobalHeld) {
FatReleaseGlobal( IrpContext );
}
}
//
// Cleanup our IrpContext and complete the IRP if neccesary.
//
FatCompleteRequest( IrpContext, Irp, Status );
return Status;
}
NTSTATUS
FatPnpCancelRemove (
PIRP_CONTEXT IrpContext,
PIRP Irp,
PVCB Vcb
)
/*++
Routine Description:
This routine handles the PnP cancel remove operation. This is our
notification that a previously proposed remove (query) was eventually
vetoed by a component. The filesystem is responsible for cleaning up
and getting ready for more IO.
Arguments:
Irp - Supplies the Irp to process
Vcb - Supplies the volume being removed.
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
//
// CANCEL - a previous QUERY has been rescinded as a result
// of someone vetoing. Since PnP cannot figure out who may
// have gotten the QUERY (think about it: stacked drivers),
// we must expect to deal with getting a CANCEL without having
// seen the QUERY.
//
// For FAT, this is quite easy. In fact, we can't get a
// CANCEL if the underlying drivers succeeded the QUERY since
// we disconnect the Vpb on our dismount initiation. This is
// actually pretty important because if PnP could get to us
// after the disconnect we'd be thoroughly unsynchronized
// with respect to the Vcb getting torn apart - merely referencing
// the volume device object is insufficient to keep us intact.
//
FatAcquireExclusiveVcb( IrpContext, Vcb );
FatReleaseGlobal( IrpContext);
//
// Unlock the volume. This is benign if we never had seen
// a QUERY.
//
(VOID)FatUnlockVolumeInternal( IrpContext, Vcb, NULL );
try {
//
// Send the request. The underlying driver will complete the
// IRP. Since we don't need to be in the way, simply ellide
// ourselves out of the IRP stack.
//
IoSkipCurrentIrpStackLocation( Irp );
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
}
finally {
FatReleaseVcb( IrpContext, Vcb );
}
FatCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
return Status;
}
NTSTATUS
FatCommonPnp (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for doing PnP operations called
by both the fsd and fsp threads
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
PVOLUME_DEVICE_OBJECT OurDeviceObject;
PVCB Vcb;
PAGED_CODE();
//
// Force everything to wait.
//
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
//
// Get the current Irp stack location.
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
//
// Find our Vcb. This is tricky since we have no file object in the Irp.
//
OurDeviceObject = (PVOLUME_DEVICE_OBJECT) IrpSp->DeviceObject;
//
// Take the global lock to synchronise against volume teardown.
//
#pragma prefast( push )
#pragma prefast( disable: 28137, "prefast wants the wait to be a constant, but that isn't possible for the way fastfat is designed" )
#pragma prefast( disable: 28193, "this will always wait" )
FatAcquireExclusiveGlobal( IrpContext );
#pragma prefast( pop )
//
// Make sure this device object really is big enough to be a volume device
// object. If it isn't, we need to get out before we try to reference some
// field that takes us past the end of an ordinary device object.
//
#pragma prefast( suppress: 28175, "touching Size is ok for a filesystem" )
if (OurDeviceObject->DeviceObject.Size != sizeof(VOLUME_DEVICE_OBJECT) ||
NodeType( &OurDeviceObject->Vcb ) != FAT_NTC_VCB) {
//
// We were called with something we don't understand.
//
FatReleaseGlobal( IrpContext );
Status = STATUS_INVALID_PARAMETER;
FatCompleteRequest( IrpContext, Irp, Status );
return Status;
}
Vcb = &OurDeviceObject->Vcb;
//
// Case on the minor code.
//
switch ( IrpSp->MinorFunction ) {
case IRP_MN_QUERY_REMOVE_DEVICE:
Status = FatPnpQueryRemove( IrpContext, Irp, Vcb );
break;
case IRP_MN_SURPRISE_REMOVAL:
Status = FatPnpSurpriseRemove( IrpContext, Irp, Vcb );
break;
case IRP_MN_REMOVE_DEVICE:
Status = FatPnpRemove( IrpContext, Irp, Vcb );
break;
case IRP_MN_CANCEL_REMOVE_DEVICE:
Status = FatPnpCancelRemove( IrpContext, Irp, Vcb );
break;
default:
FatReleaseGlobal( IrpContext );
//
// Just pass the IRP on. As we do not need to be in the
// way on return, ellide ourselves out of the stack.
//
IoSkipCurrentIrpStackLocation( Irp );
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
//
// Cleanup our Irp Context. The driver has completed the Irp.
//
FatCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
break;
}
return Status;
}
NTSTATUS
FatCommonPnp (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This is the common routine for doing PnP operations called
by both the fsd and fsp threads
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
PVOLUME_DEVICE_OBJECT OurDeviceObject;
PVCB Vcb;
//
// Force everything to wait.
//
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
//
// Get the current Irp stack location.
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
//
// Find our Vcb. This is tricky since we have no file object in the Irp.
//
OurDeviceObject = (PVOLUME_DEVICE_OBJECT) IrpSp->DeviceObject;
//
// Take the global lock to synchronise against volume teardown.
//
FatAcquireExclusiveGlobal( IrpContext );
//
// Make sure this device object really is big enough to be a volume device
// object. If it isn't, we need to get out before we try to reference some
// field that takes us past the end of an ordinary device object.
//
if (OurDeviceObject->DeviceObject.Size != sizeof(VOLUME_DEVICE_OBJECT) ||
NodeType( &OurDeviceObject->Vcb ) != FAT_NTC_VCB) {
//
// We were called with something we don't understand.
//
FatReleaseGlobal( IrpContext );
Status = STATUS_INVALID_PARAMETER;
FatCompleteRequest( IrpContext, Irp, Status );
return Status;
}
#if __NDAS_FAT__
if (OurDeviceObject->NetdiskEnableMode == NETDISK_SECONDARY)
SetFlag( IrpContext->NdFatFlags, ND_FAT_IRP_CONTEXT_FLAG_SECONDARY_CONTEXT );
#endif
Vcb = &OurDeviceObject->Vcb;
//
// Case on the minor code.
//
#if __NDAS_FAT_SECONDARY__
if ( ((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->Secondary &&
( ((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->NetdiskEnableMode == NETDISK_SECONDARY ||
((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->NetdiskEnableMode == NETDISK_SECONDARY2PRIMARY ) )
{
PSECONDARY Secondary = ((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->Secondary;
Status = STATUS_SUCCESS;
Secondary_Reference( Secondary );
switch ( IrpSp->MinorFunction ) {
case IRP_MN_QUERY_REMOVE_DEVICE: {
DebugTrace2( 0, Dbg, ("FatCommonPnp: IRP_MN_QUERY_REMOVE_DEVICE NetdiskEnableMode = %d\n", ((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->NetdiskEnableMode) );
ExAcquireFastMutex( &Secondary->FastMutex );
if (!Secondary->TryCloseActive) {
Secondary->TryCloseActive = TRUE;
ExReleaseFastMutex( &Secondary->FastMutex );
Secondary_Reference( Secondary );
//FatDebugTraceLevel |= DEBUG_TRACE_CLOSE;
SecondaryTryClose( IrpContext, Secondary );
//FatDebugTraceLevel &= ~DEBUG_TRACE_CLOSE;
} else {
ExReleaseFastMutex( &Secondary->FastMutex );
}
if (Vcb->SecondaryOpenFileCount) {
LARGE_INTEGER interval;
// Wait all files closed
interval.QuadPart = (1 * HZ); //delay 1 seconds
KeDelayExecutionThread(KernelMode, FALSE, &interval);
}
#if 0
if (Vcb->SecondaryOpenFileCount) {
LONG ccbCount;
PLIST_ENTRY ccbListEntry;
PVOID restartKey;
PFCB fcb;
ExAcquireFastMutex( &Secondary->RecoveryCcbQMutex );
for (ccbCount = 0, ccbListEntry = Secondary->RecoveryCcbQueue.Flink;
ccbListEntry != &Secondary->RecoveryCcbQueue;
ccbListEntry = ccbListEntry->Flink, ccbCount++);
ExReleaseFastMutex( &Secondary->RecoveryCcbQMutex );
ASSERT( !IsListEmpty(&Secondary->RecoveryCcbQueue) );
ASSERT( ccbCount == Vcb->SecondaryOpenFileCount );
DebugTrace2( 0, Dbg, ("IRP_MN_QUERY_REMOVE_DEVICE: Vcb->SecondaryCloseCount = %d, Vcb->CloseCount = %d, ccbCount = %d\n",
Vcb->SecondaryOpenFileCount, Vcb->OpenCount, ccbCount) );
restartKey = NULL;
fcb = NdFatGetNextFcbTableEntry( &Secondary->VolDo->Vcb, &restartKey );
ASSERT( fcb != NULL || !IsListEmpty(&Secondary->DeletedFcbQueue) );
Status = STATUS_UNSUCCESSFUL;
}
#endif
break;
}
case IRP_MN_REMOVE_DEVICE: {
PVOID restartKey;
PFCB fcb;
DebugTrace2( 0, Dbg, ("FatCommonPnp: IRP_MN_REMOVE_DEVICE NetdiskEnableMode = %d\n", ((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->NetdiskEnableMode) );
#if 0
restartKey = NULL;
fcb = NdFatGetNextFcbTableEntry( &Secondary->VolDo->Vcb, &restartKey );
ASSERT( fcb == NULL && IsListEmpty(&Secondary->DeletedFcbQueue) );
#endif
if (Vcb->SecondaryOpenFileCount) {
ASSERT( NDFAT_BUG );
Status = STATUS_UNSUCCESSFUL;
}
break;
}
default: {
DebugTrace2( 0, Dbg, ("FatCommonPnp: IrpSp-MinorFunction = %d NetdiskEnableMode = %d\n",
IrpSp->MinorFunction, ((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->NetdiskEnableMode) );
if (IrpSp->MinorFunction != IRP_MN_QUERY_DEVICE_RELATIONS) {
if (IrpSp->FileObject && IS_SECONDARY_FILEOBJECT(IrpSp->FileObject)) {
ASSERT( FALSE );
}
}
Status = STATUS_SUCCESS;
break;
}
}
Secondary_Dereference( Secondary );
if (!NT_SUCCESS(Status)) {
FatCompleteRequest( NULL, Irp, Status );
return Status;
}
}
#endif
switch ( IrpSp->MinorFunction ) {
case IRP_MN_QUERY_REMOVE_DEVICE:
Status = FatPnpQueryRemove( IrpContext, Irp, Vcb );
break;
case IRP_MN_SURPRISE_REMOVAL:
Status = FatPnpSurpriseRemove( IrpContext, Irp, Vcb );
break;
case IRP_MN_REMOVE_DEVICE:
Status = FatPnpRemove( IrpContext, Irp, Vcb );
break;
case IRP_MN_CANCEL_REMOVE_DEVICE:
Status = FatPnpCancelRemove( IrpContext, Irp, Vcb );
break;
default:
FatReleaseGlobal( IrpContext );
//
// Just pass the IRP on. As we do not need to be in the
// way on return, ellide ourselves out of the stack.
//
IoSkipCurrentIrpStackLocation( Irp );
Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
//
// Cleanup our Irp Context. The driver has completed the Irp.
//
FatCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
break;
}
return Status;
}
NTSTATUS
NTAPI
FatMountVolume(PFAT_IRP_CONTEXT IrpContext,
PDEVICE_OBJECT TargetDeviceObject,
PVPB Vpb,
PDEVICE_OBJECT FsDeviceObject)
{
NTSTATUS Status;
DISK_GEOMETRY DiskGeometry;
ULONG MediaChangeCount = 0;
PVOLUME_DEVICE_OBJECT VolumeDevice;
VCB *Vcb;
FF_ERROR Error;
PBCB BootBcb;
PPACKED_BOOT_SECTOR BootSector;
DPRINT1("FatMountVolume()\n");
/* Make sure this IRP is waitable */
ASSERT(IrpContext->Flags & IRPCONTEXT_CANWAIT);
/* Request media changes count, mostly useful for removable devices */
Status = FatPerformDevIoCtrl(TargetDeviceObject,
IOCTL_STORAGE_CHECK_VERIFY,
NULL,
0,
&MediaChangeCount,
sizeof(ULONG),
TRUE);
if (!NT_SUCCESS(Status)) return Status;
/* TODO: Check if data-track present in case of a CD drive */
/* TODO: IOCTL_DISK_GET_PARTITION_INFO_EX */
/* Remove unmounted VCBs */
FatiCleanVcbs(IrpContext);
/* Acquire the global exclusive lock */
FatAcquireExclusiveGlobal(IrpContext);
/* Create a new volume device object */
Status = IoCreateDevice(FatGlobalData.DriverObject,
sizeof(VOLUME_DEVICE_OBJECT) - sizeof(DEVICE_OBJECT),
NULL,
FILE_DEVICE_DISK_FILE_SYSTEM,
0,
FALSE,
(PDEVICE_OBJECT *)&VolumeDevice);
if (!NT_SUCCESS(Status))
{
/* Release the global lock */
FatReleaseGlobal(IrpContext);
return Status;
}
/* Match alignment requirements */
if (TargetDeviceObject->AlignmentRequirement > VolumeDevice->DeviceObject.AlignmentRequirement)
{
VolumeDevice->DeviceObject.AlignmentRequirement = TargetDeviceObject->AlignmentRequirement;
}
/* Init stack size */
VolumeDevice->DeviceObject.StackSize = TargetDeviceObject->StackSize + 1;
/* Get sector size */
Status = FatPerformDevIoCtrl(TargetDeviceObject,
IOCTL_DISK_GET_DRIVE_GEOMETRY,
NULL,
0,
&DiskGeometry,
sizeof(DISK_GEOMETRY),
TRUE);
if (!NT_SUCCESS(Status)) goto FatMountVolumeCleanup;
VolumeDevice->DeviceObject.SectorSize = (USHORT) DiskGeometry.BytesPerSector;
/* Signal we're done with initializing */
VolumeDevice->DeviceObject.Flags &= ~DO_DEVICE_INITIALIZING;
/* Save device object in a VPB */
Vpb->DeviceObject = (PDEVICE_OBJECT)VolumeDevice;
/* Initialize VCB for this volume */
Status = FatInitializeVcb(IrpContext, &VolumeDevice->Vcb, TargetDeviceObject, Vpb);
if (!NT_SUCCESS(Status)) goto FatMountVolumeCleanup;
Vcb = &VolumeDevice->Vcb;
/* Initialize FullFAT library */
Vcb->Ioman = FF_CreateIOMAN(NULL,
8192,
VolumeDevice->DeviceObject.SectorSize,
&Error);
ASSERT(Vcb->Ioman);
/* Register block device read/write functions */
Error = FF_RegisterBlkDevice(Vcb->Ioman,
VolumeDevice->DeviceObject.SectorSize,
(FF_WRITE_BLOCKS)FatWriteBlocks,
(FF_READ_BLOCKS)FatReadBlocks,
Vcb);
if (Error)
{
DPRINT1("Registering block device with FullFAT failed with error %d\n", Error);
FF_DestroyIOMAN(Vcb->Ioman);
goto FatMountVolumeCleanup;
}
/* Mount the volume using FullFAT */
if(FF_MountPartition(Vcb->Ioman, 0))
{
DPRINT1("Partition mounting failed\n");
FF_DestroyIOMAN(Vcb->Ioman);
goto FatMountVolumeCleanup;
}
/* Read the boot sector */
FatReadStreamFile(Vcb, 0, sizeof(PACKED_BOOT_SECTOR), &BootBcb, (PVOID)&BootSector);
/* Check if it's successful */
if (!BootBcb)
{
Status = STATUS_UNRECOGNIZED_VOLUME;
goto FatMountVolumeCleanup;
}
/* Unpack data */
FatiUnpackBpb(&Vcb->Bpb, &BootSector->PackedBpb);
/* Verify if sector size matches */
if (DiskGeometry.BytesPerSector != Vcb->Bpb.BytesPerSector)
{
DPRINT1("Disk geometry BPS %d and bios BPS %d don't match!\n",
DiskGeometry.BytesPerSector, Vcb->Bpb.BytesPerSector);
/* Fail */
Status = STATUS_UNRECOGNIZED_VOLUME;
goto FatMountVolumeCleanup;
}
/* If Sectors value is set, discard the LargeSectors value */
if (Vcb->Bpb.Sectors) Vcb->Bpb.LargeSectors = 0;
/* Copy serial number */
if (FatiBpbFat32(&BootSector->PackedBpb))
{
CopyUchar4(&Vpb->SerialNumber, ((PPACKED_BOOT_SECTOR_EX)BootSector)->Id);
}
else
{
/* This is FAT12/16 */
CopyUchar4(&Vpb->SerialNumber, BootSector->Id);
}
/* Unpin the BCB */
CcUnpinData(BootBcb);
/* Create root DCB for it */
FatCreateRootDcb(IrpContext, &VolumeDevice->Vcb);
/* Keep trace of media changes */
VolumeDevice->Vcb.MediaChangeCount = MediaChangeCount;
//ObDereferenceObject(TargetDeviceObject);
/* Release the global lock */
FatReleaseGlobal(IrpContext);
/* Notify about volume mount */
//FsRtlNotifyVolumeEvent(VolumeDevice->Vcb.StreamFileObject, FSRTL_VOLUME_MOUNT);
/* Return success */
return STATUS_SUCCESS;
FatMountVolumeCleanup:
/* Unwind the routine actions */
IoDeleteDevice((PDEVICE_OBJECT)VolumeDevice);
/* Release the global lock */
FatReleaseGlobal(IrpContext);
return Status;
}