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.
1034 lines
32 KiB
1034 lines
32 KiB
/*++
|
|
|
|
Copyright (c) 1989-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Cleanup.c
|
|
|
|
Abstract:
|
|
|
|
This module implements the File Cleanup routine for Fat called by the
|
|
dispatch driver.
|
|
|
|
// @@BEGIN_DDKSPLIT
|
|
|
|
Author:
|
|
|
|
Gary Kimura [GaryKi] 28-Dec-1989
|
|
|
|
Revision History:
|
|
|
|
// @@END_DDKSPLIT
|
|
|
|
--*/
|
|
|
|
#include "FatProcs.h"
|
|
|
|
//
|
|
// The Bug check file id for this module
|
|
//
|
|
|
|
#define BugCheckFileId (FAT_BUG_CHECK_CLEANUP)
|
|
|
|
//
|
|
// The local debug trace level
|
|
//
|
|
|
|
#define Dbg (DEBUG_TRACE_CLEANUP)
|
|
|
|
//
|
|
// The following little routine exists solely because it need a spin lock.
|
|
//
|
|
|
|
VOID
|
|
FatAutoUnlock (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
IN PVCB Vcb
|
|
);
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE, FatCommonCleanup)
|
|
#pragma alloc_text(PAGE, FatFsdCleanup)
|
|
#endif
|
|
|
|
|
|
NTSTATUS
|
|
FatFsdCleanup (
|
|
IN PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine implements the FSD part of closing down a handle to a
|
|
file object.
|
|
|
|
Arguments:
|
|
|
|
VolumeDeviceObject - Supplies the volume device object where the
|
|
file being Cleanup exists
|
|
|
|
Irp - Supplies the Irp being processed
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - The FSD status for the IRP
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status;
|
|
PIRP_CONTEXT IrpContext = NULL;
|
|
|
|
BOOLEAN TopLevel;
|
|
|
|
//
|
|
// If we were called with our file system device object instead of a
|
|
// volume device object, just complete this request with STATUS_SUCCESS
|
|
//
|
|
|
|
if ( FatDeviceIsFatFsdo( VolumeDeviceObject)) {
|
|
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Irp->IoStatus.Information = FILE_OPENED;
|
|
|
|
IoCompleteRequest( Irp, IO_DISK_INCREMENT );
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
DebugTrace(+1, Dbg, "FatFsdCleanup\n", 0);
|
|
|
|
//
|
|
// Call the common Cleanup routine, with blocking allowed.
|
|
//
|
|
|
|
FsRtlEnterFileSystem();
|
|
|
|
TopLevel = FatIsIrpTopLevel( Irp );
|
|
|
|
try {
|
|
|
|
IrpContext = FatCreateIrpContext( Irp, TRUE );
|
|
|
|
Status = FatCommonCleanup( IrpContext, Irp );
|
|
|
|
} except(FatExceptionFilter( IrpContext, GetExceptionInformation() )) {
|
|
|
|
//
|
|
// We had some trouble trying to perform the requested
|
|
// operation, 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() );
|
|
}
|
|
|
|
if (TopLevel) { IoSetTopLevelIrp( NULL ); }
|
|
|
|
FsRtlExitFileSystem();
|
|
|
|
//
|
|
// And return to our caller
|
|
//
|
|
|
|
DebugTrace(-1, Dbg, "FatFsdCleanup -> %08lx\n", Status);
|
|
|
|
UNREFERENCED_PARAMETER( VolumeDeviceObject );
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
FatCommonCleanup (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
IN PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the common routine for cleanup of a file/directory called by both
|
|
the fsd and fsp threads.
|
|
|
|
Cleanup is invoked whenever the last handle to a file object is closed.
|
|
This is different than the Close operation which is invoked when the last
|
|
reference to a file object is deleted.
|
|
|
|
The function of cleanup is to essentially "cleanup" the file/directory
|
|
after a user is done with it. The Fcb/Dcb remains around (because MM
|
|
still has the file object referenced) but is now available for another
|
|
user to open (i.e., as far as the user is concerned the is now closed).
|
|
|
|
See close for a more complete description of what close does.
|
|
|
|
Arguments:
|
|
|
|
Irp - Supplies the Irp to process
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - The return status for the operation
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status;
|
|
|
|
PIO_STACK_LOCATION IrpSp;
|
|
|
|
PFILE_OBJECT FileObject;
|
|
|
|
TYPE_OF_OPEN TypeOfOpen;
|
|
PVCB Vcb;
|
|
PFCB Fcb;
|
|
PCCB Ccb;
|
|
|
|
BOOLEAN SendUnlockNotification = FALSE;
|
|
|
|
PSHARE_ACCESS ShareAccess;
|
|
|
|
PLARGE_INTEGER TruncateSize = NULL;
|
|
LARGE_INTEGER LocalTruncateSize;
|
|
|
|
BOOLEAN AcquiredVcb = FALSE;
|
|
BOOLEAN AcquiredFcb = FALSE;
|
|
|
|
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
|
|
|
DebugTrace(+1, Dbg, "FatCommonCleanup\n", 0);
|
|
DebugTrace( 0, Dbg, "Irp = %08lx\n", Irp);
|
|
DebugTrace( 0, Dbg, "->FileObject = %08lx\n", IrpSp->FileObject);
|
|
|
|
//
|
|
// Extract and decode the file object
|
|
//
|
|
|
|
FileObject = IrpSp->FileObject;
|
|
TypeOfOpen = FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb );
|
|
|
|
//
|
|
// Special case the unopened file object. This will occur only when
|
|
// we are initializing Vcb and IoCreateStreamFileObject is being
|
|
// called.
|
|
//
|
|
|
|
if (TypeOfOpen == UnopenedFileObject) {
|
|
|
|
DebugTrace(0, Dbg, "Unopened File Object\n", 0);
|
|
|
|
FatCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
|
|
|
|
DebugTrace(-1, Dbg, "FatCommonCleanup -> STATUS_SUCCESS\n", 0);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// If this is not our first time through (for whatever reason)
|
|
// only see if we have to flush the file.
|
|
//
|
|
|
|
if (FlagOn( FileObject->Flags, FO_CLEANUP_COMPLETE )) {
|
|
|
|
if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_DEFERRED_FLUSH) &&
|
|
FlagOn(FileObject->Flags, FO_FILE_MODIFIED) &&
|
|
!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_WRITE_PROTECTED) &&
|
|
(TypeOfOpen == UserFileOpen)) {
|
|
|
|
//
|
|
// Flush the file.
|
|
//
|
|
|
|
Status = FatFlushFile( IrpContext, Fcb, Flush );
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
|
|
FatNormalizeAndRaiseStatus( IrpContext, Status );
|
|
}
|
|
}
|
|
|
|
FatCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
|
|
|
|
DebugTrace(-1, Dbg, "FatCommonCleanup -> STATUS_SUCCESS\n", 0);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// If we call change the allocation or call CcUninitialize,
|
|
// we have to take the Fcb exclusive
|
|
//
|
|
|
|
if ((TypeOfOpen == UserFileOpen) || (TypeOfOpen == UserDirectoryOpen)) {
|
|
|
|
ASSERT( Fcb != NULL );
|
|
|
|
(VOID)FatAcquireExclusiveFcb( IrpContext, Fcb );
|
|
|
|
AcquiredFcb = TRUE;
|
|
|
|
//
|
|
// Do a check here if this was a DELETE_ON_CLOSE FileObject, and
|
|
// set the Fcb flag appropriately.
|
|
//
|
|
|
|
if (FlagOn(Ccb->Flags, CCB_FLAG_DELETE_ON_CLOSE)) {
|
|
|
|
ASSERT( NodeType(Fcb) != FAT_NTC_ROOT_DCB );
|
|
|
|
SetFlag(Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE);
|
|
|
|
//
|
|
// Report this to the dir notify package for a directory.
|
|
//
|
|
|
|
if (TypeOfOpen == UserDirectoryOpen) {
|
|
|
|
FsRtlNotifyFullChangeDirectory( Vcb->NotifySync,
|
|
&Vcb->DirNotifyList,
|
|
FileObject->FsContext,
|
|
NULL,
|
|
FALSE,
|
|
FALSE,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
NULL );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now if we may delete the file, drop the Fcb and acquire the Vcb
|
|
// first. Note that while we own the Fcb exclusive, a file cannot
|
|
// become DELETE_ON_CLOSE and cannot be opened via CommonCreate.
|
|
//
|
|
|
|
if ((Fcb->UncleanCount == 1) &&
|
|
FlagOn(Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE) &&
|
|
(Fcb->FcbCondition != FcbBad) &&
|
|
!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_WRITE_PROTECTED)) {
|
|
|
|
FatReleaseFcb( IrpContext, Fcb );
|
|
AcquiredFcb = FALSE;
|
|
|
|
(VOID)FatAcquireExclusiveVcb( IrpContext, Vcb );
|
|
AcquiredVcb = TRUE;
|
|
|
|
(VOID)FatAcquireExclusiveFcb( IrpContext, Fcb );
|
|
AcquiredFcb = TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// For user DASD cleanups, grab the Vcb exclusive.
|
|
//
|
|
|
|
if (TypeOfOpen == UserVolumeOpen) {
|
|
|
|
(VOID)FatAcquireExclusiveVcb( IrpContext, Vcb );
|
|
AcquiredVcb = TRUE;
|
|
}
|
|
|
|
//
|
|
// Complete any Notify Irps on this file handle.
|
|
//
|
|
|
|
if (TypeOfOpen == UserDirectoryOpen) {
|
|
|
|
FsRtlNotifyCleanup( Vcb->NotifySync,
|
|
&Vcb->DirNotifyList,
|
|
Ccb );
|
|
}
|
|
|
|
//
|
|
// Determine the Fcb state, Good or Bad, for better or for worse.
|
|
//
|
|
// We can only read the volume file if VcbCondition is good.
|
|
//
|
|
|
|
if ( Fcb != NULL) {
|
|
|
|
//
|
|
// Stop any raises from FatVerifyFcb, unless it is REAL bad.
|
|
//
|
|
|
|
try {
|
|
|
|
try {
|
|
|
|
FatVerifyFcb( IrpContext, Fcb );
|
|
|
|
} except( FsRtlIsNtstatusExpected(GetExceptionCode()) ?
|
|
EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) {
|
|
|
|
FatResetExceptionState( IrpContext );
|
|
}
|
|
|
|
} finally {
|
|
|
|
if ( AbnormalTermination() ) {
|
|
|
|
//
|
|
// We will be raising out of here.
|
|
//
|
|
|
|
if (AcquiredFcb) { FatReleaseFcb( IrpContext, Fcb ); }
|
|
if (AcquiredVcb) { FatReleaseVcb( IrpContext, Vcb ); }
|
|
}
|
|
}
|
|
}
|
|
|
|
try {
|
|
|
|
//
|
|
// Case on the type of open that we are trying to cleanup.
|
|
// For all cases we need to set the share access to point to the
|
|
// share access variable (if there is one). After the switch
|
|
// we then remove the share access and complete the Irp.
|
|
// In the case of UserFileOpen we actually have a lot more work
|
|
// to do and we have the FsdLockControl complete the Irp for us.
|
|
//
|
|
|
|
switch (TypeOfOpen) {
|
|
|
|
case DirectoryFile:
|
|
case VirtualVolumeFile:
|
|
|
|
DebugTrace(0, Dbg, "Cleanup VirtualVolumeFile/DirectoryFile\n", 0);
|
|
|
|
ShareAccess = NULL;
|
|
|
|
break;
|
|
|
|
case UserVolumeOpen:
|
|
|
|
DebugTrace(0, Dbg, "Cleanup UserVolumeOpen\n", 0);
|
|
|
|
if (FlagOn( Ccb->Flags, CCB_FLAG_COMPLETE_DISMOUNT )) {
|
|
|
|
FatCheckForDismount( IrpContext, Vcb, TRUE );
|
|
|
|
//
|
|
// If this handle had write access, and actually wrote something,
|
|
// flush the device buffers, and then set the verify bit now
|
|
// just to be safe (in case there is no dismount).
|
|
//
|
|
|
|
} else if (FileObject->WriteAccess &&
|
|
FlagOn(FileObject->Flags, FO_FILE_MODIFIED)) {
|
|
|
|
(VOID)FatHijackIrpAndFlushDevice( IrpContext,
|
|
Irp,
|
|
Vcb->TargetDeviceObject );
|
|
|
|
SetFlag(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME);
|
|
}
|
|
|
|
//
|
|
// If the volume is locked by this file object then release
|
|
// the volume and send notification.
|
|
//
|
|
|
|
if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_LOCKED) &&
|
|
(Vcb->FileObjectWithVcbLocked == FileObject)) {
|
|
|
|
FatAutoUnlock( IrpContext, Vcb );
|
|
SendUnlockNotification = TRUE;
|
|
}
|
|
|
|
ShareAccess = &Vcb->ShareAccess;
|
|
|
|
break;
|
|
|
|
case EaFile:
|
|
|
|
DebugTrace(0, Dbg, "Cleanup EaFileObject\n", 0);
|
|
|
|
ShareAccess = NULL;
|
|
|
|
break;
|
|
|
|
case UserDirectoryOpen:
|
|
|
|
DebugTrace(0, Dbg, "Cleanup UserDirectoryOpen\n", 0);
|
|
|
|
ShareAccess = &Fcb->ShareAccess;
|
|
|
|
//
|
|
// Determine here if we should try do delayed close.
|
|
//
|
|
|
|
if ((Fcb->UncleanCount == 1) &&
|
|
(Fcb->OpenCount == 1) &&
|
|
(Fcb->Specific.Dcb.DirectoryFileOpenCount == 0) &&
|
|
!FlagOn(Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE) &&
|
|
Fcb->FcbCondition == FcbGood) {
|
|
|
|
//
|
|
// Delay our close.
|
|
//
|
|
|
|
SetFlag( Fcb->FcbState, FCB_STATE_DELAY_CLOSE );
|
|
}
|
|
|
|
FatUpdateDirentFromFcb( IrpContext, FileObject, Fcb, Ccb );
|
|
|
|
//
|
|
// If the directory has a unclean count of 1 then we know
|
|
// that this is the last handle for the file object. If
|
|
// we are supposed to delete it, do so.
|
|
//
|
|
|
|
if ((Fcb->UncleanCount == 1) &&
|
|
(NodeType(Fcb) == FAT_NTC_DCB) &&
|
|
(FlagOn(Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE)) &&
|
|
(Fcb->FcbCondition != FcbBad) &&
|
|
!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_WRITE_PROTECTED)) {
|
|
|
|
if (!FatIsDirectoryEmpty(IrpContext, Fcb)) {
|
|
|
|
//
|
|
// If there are files in the directory at this point,
|
|
// forget that we were trying to delete it.
|
|
//
|
|
|
|
ClearFlag( Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE );
|
|
|
|
} else {
|
|
|
|
//
|
|
// Even if something goes wrong, we cannot turn back!
|
|
//
|
|
|
|
try {
|
|
|
|
DELETE_CONTEXT DeleteContext;
|
|
|
|
//
|
|
// Before truncating file allocation remember this
|
|
// info for FatDeleteDirent.
|
|
//
|
|
|
|
DeleteContext.FileSize = Fcb->Header.FileSize.LowPart;
|
|
DeleteContext.FirstClusterOfFile = Fcb->FirstClusterOfFile;
|
|
|
|
//
|
|
// Synchronize here with paging IO
|
|
//
|
|
|
|
(VOID)ExAcquireResourceExclusiveLite( Fcb->Header.PagingIoResource,
|
|
TRUE );
|
|
|
|
Fcb->Header.FileSize.LowPart = 0;
|
|
|
|
ExReleaseResourceLite( Fcb->Header.PagingIoResource );
|
|
|
|
if (Vcb->VcbCondition == VcbGood) {
|
|
|
|
//
|
|
// Truncate the file allocation down to zero
|
|
//
|
|
|
|
DebugTrace(0, Dbg, "Delete File allocation\n", 0);
|
|
|
|
FatTruncateFileAllocation( IrpContext, Fcb, 0 );
|
|
|
|
if (Fcb->Header.AllocationSize.LowPart == 0) {
|
|
|
|
//
|
|
// Tunnel and remove the dirent for the directory
|
|
//
|
|
|
|
DebugTrace(0, Dbg, "Delete the directory dirent\n", 0);
|
|
|
|
FatTunnelFcbOrDcb( Fcb, NULL );
|
|
|
|
FatDeleteDirent( IrpContext, Fcb, &DeleteContext, TRUE );
|
|
|
|
//
|
|
// Report that we have removed an entry.
|
|
//
|
|
|
|
FatNotifyReportChange( IrpContext,
|
|
Vcb,
|
|
Fcb,
|
|
FILE_NOTIFY_CHANGE_DIR_NAME,
|
|
FILE_ACTION_REMOVED );
|
|
}
|
|
}
|
|
|
|
} except( FsRtlIsNtstatusExpected(GetExceptionCode()) ?
|
|
EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) {
|
|
|
|
FatResetExceptionState( IrpContext );
|
|
}
|
|
|
|
//
|
|
// Remove the entry from the name table.
|
|
// This will ensure that
|
|
// we will not collide with the Dcb if the user wants
|
|
// to recreate the same file over again before we
|
|
// get a close irp.
|
|
//
|
|
|
|
FatRemoveNames( IrpContext, Fcb );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Decrement the unclean count.
|
|
//
|
|
|
|
ASSERT( Fcb->UncleanCount != 0 );
|
|
Fcb->UncleanCount -= 1;
|
|
|
|
break;
|
|
|
|
case UserFileOpen:
|
|
|
|
DebugTrace(0, Dbg, "Cleanup UserFileOpen\n", 0);
|
|
|
|
ShareAccess = &Fcb->ShareAccess;
|
|
|
|
//
|
|
// Determine here if we should do a delayed close.
|
|
//
|
|
|
|
if ((FileObject->SectionObjectPointer->DataSectionObject == NULL) &&
|
|
(FileObject->SectionObjectPointer->ImageSectionObject == NULL) &&
|
|
(Fcb->UncleanCount == 1) &&
|
|
(Fcb->OpenCount == 1) &&
|
|
!FlagOn(Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE) &&
|
|
Fcb->FcbCondition == FcbGood) {
|
|
|
|
//
|
|
// Delay our close.
|
|
//
|
|
|
|
SetFlag( Fcb->FcbState, FCB_STATE_DELAY_CLOSE );
|
|
}
|
|
|
|
//
|
|
// Unlock all outstanding file locks.
|
|
//
|
|
|
|
(VOID) FsRtlFastUnlockAll( &Fcb->Specific.Fcb.FileLock,
|
|
FileObject,
|
|
IoGetRequestorProcess( Irp ),
|
|
NULL );
|
|
|
|
//
|
|
// We can proceed with on-disk updates only if the volume is mounted.
|
|
// Remember that we toss all sections in the failed-verify and dismount
|
|
// cases.
|
|
//
|
|
|
|
if (Vcb->VcbCondition == VcbGood) {
|
|
|
|
if (Fcb->FcbCondition != FcbBad) {
|
|
|
|
FatUpdateDirentFromFcb( IrpContext, FileObject, Fcb, Ccb );
|
|
}
|
|
|
|
//
|
|
// If the file has a unclean count of 1 then we know
|
|
// that this is the last handle for the file object.
|
|
//
|
|
|
|
if ( (Fcb->UncleanCount == 1) && (Fcb->FcbCondition != FcbBad) ) {
|
|
|
|
DELETE_CONTEXT DeleteContext;
|
|
|
|
//
|
|
// Check if we should be deleting the file. The
|
|
// delete operation really deletes the file but
|
|
// keeps the Fcb around for close to do away with.
|
|
//
|
|
|
|
if (FlagOn(Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE) &&
|
|
!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_WRITE_PROTECTED)) {
|
|
|
|
//
|
|
// Before truncating file allocation remember this
|
|
// info for FatDeleteDirent.
|
|
//
|
|
|
|
DeleteContext.FileSize = Fcb->Header.FileSize.LowPart;
|
|
DeleteContext.FirstClusterOfFile = Fcb->FirstClusterOfFile;
|
|
|
|
DebugTrace(0, Dbg, "Delete File allocation\n", 0);
|
|
|
|
//
|
|
// Synchronize here with paging IO
|
|
//
|
|
|
|
(VOID)ExAcquireResourceExclusiveLite( Fcb->Header.PagingIoResource,
|
|
TRUE );
|
|
|
|
Fcb->Header.FileSize.LowPart = 0;
|
|
Fcb->Header.ValidDataLength.LowPart = 0;
|
|
Fcb->ValidDataToDisk = 0;
|
|
|
|
ExReleaseResourceLite( Fcb->Header.PagingIoResource );
|
|
|
|
try {
|
|
|
|
FatSetFileSizeInDirent( IrpContext, Fcb, NULL );
|
|
|
|
} except( FsRtlIsNtstatusExpected(GetExceptionCode()) ?
|
|
EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) {
|
|
|
|
FatResetExceptionState( IrpContext );
|
|
}
|
|
|
|
Fcb->FcbState |= FCB_STATE_TRUNCATE_ON_CLOSE;
|
|
|
|
} else {
|
|
|
|
//
|
|
// We must zero between ValidDataLength and FileSize
|
|
//
|
|
|
|
if (!FlagOn(Fcb->FcbState, FCB_STATE_PAGING_FILE) &&
|
|
(Fcb->Header.ValidDataLength.LowPart < Fcb->Header.FileSize.LowPart)) {
|
|
|
|
ULONG ValidDataLength;
|
|
|
|
ValidDataLength = Fcb->Header.ValidDataLength.LowPart;
|
|
|
|
if (ValidDataLength < Fcb->ValidDataToDisk) {
|
|
ValidDataLength = Fcb->ValidDataToDisk;
|
|
}
|
|
|
|
//
|
|
// Recheck, VDD can be >= FS
|
|
//
|
|
|
|
if (ValidDataLength < Fcb->Header.FileSize.LowPart) {
|
|
|
|
try {
|
|
|
|
(VOID)FatZeroData( IrpContext,
|
|
Vcb,
|
|
FileObject,
|
|
ValidDataLength,
|
|
Fcb->Header.FileSize.LowPart -
|
|
ValidDataLength );
|
|
|
|
//
|
|
// Since we just zeroed this, we can now bump
|
|
// up VDL in the Fcb.
|
|
//
|
|
|
|
Fcb->ValidDataToDisk =
|
|
Fcb->Header.ValidDataLength.LowPart =
|
|
Fcb->Header.FileSize.LowPart;
|
|
|
|
//
|
|
// We inform Cc of the motion so that the cache map is updated.
|
|
// This prevents optimized zero-page faults in case the cache
|
|
// structures are re-used for another handle before they are torn
|
|
// down by our soon-to-occur uninitialize. If they were, a noncached
|
|
// producer could write into the region we just zeroed and Cc would
|
|
// be none the wiser, then our async cached reader comes in and takes
|
|
// the optimized path, and we get bad (zero) data.
|
|
//
|
|
// If this was memory mapped, we don't have to (can't) tell Cc, it'll
|
|
// figure it out when a cached handle is opened.
|
|
//
|
|
|
|
if (CcIsFileCached( FileObject )) {
|
|
CcSetFileSizes( FileObject, (PCC_FILE_SIZES)&Fcb->Header.AllocationSize );
|
|
}
|
|
|
|
} except( FsRtlIsNtstatusExpected(GetExceptionCode()) ?
|
|
EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) {
|
|
|
|
FatResetExceptionState( IrpContext );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// See if we are supposed to truncate the file on the last
|
|
// close. If we cannot wait we'll ship this off to the fsp
|
|
//
|
|
|
|
try {
|
|
|
|
if (FlagOn(Fcb->FcbState, FCB_STATE_TRUNCATE_ON_CLOSE)) {
|
|
|
|
DebugTrace(0, Dbg, "truncate file allocation\n", 0);
|
|
|
|
if (Vcb->VcbCondition == VcbGood) {
|
|
|
|
FatTruncateFileAllocation( IrpContext,
|
|
Fcb,
|
|
Fcb->Header.FileSize.LowPart );
|
|
}
|
|
|
|
//
|
|
// We also have to get rid of the Cache Map because
|
|
// this is the only way we have of trashing the
|
|
// truncated pages.
|
|
//
|
|
|
|
LocalTruncateSize = Fcb->Header.FileSize;
|
|
TruncateSize = &LocalTruncateSize;
|
|
|
|
//
|
|
// Mark the Fcb as having now been truncated, just incase
|
|
// we have to reship this off to the fsp.
|
|
//
|
|
|
|
Fcb->FcbState &= ~FCB_STATE_TRUNCATE_ON_CLOSE;
|
|
}
|
|
|
|
//
|
|
// Now check again if we are to delete the file and if
|
|
// so then we remove the file from the disk.
|
|
//
|
|
|
|
if (FlagOn(Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE) &&
|
|
Fcb->Header.AllocationSize.LowPart == 0) {
|
|
|
|
DebugTrace(0, Dbg, "Delete File\n", 0);
|
|
|
|
//
|
|
// Now tunnel and delete the dirent
|
|
//
|
|
|
|
FatTunnelFcbOrDcb( Fcb, Ccb );
|
|
|
|
FatDeleteDirent( IrpContext, Fcb, &DeleteContext, TRUE );
|
|
|
|
//
|
|
// Report that we have removed an entry.
|
|
//
|
|
|
|
FatNotifyReportChange( IrpContext,
|
|
Vcb,
|
|
Fcb,
|
|
FILE_NOTIFY_CHANGE_FILE_NAME,
|
|
FILE_ACTION_REMOVED );
|
|
}
|
|
|
|
} except( FsRtlIsNtstatusExpected(GetExceptionCode()) ?
|
|
EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) {
|
|
|
|
FatResetExceptionState( IrpContext );
|
|
}
|
|
|
|
if (FlagOn(Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE)) {
|
|
|
|
//
|
|
// Remove the entry from the splay table. This will
|
|
// ensure that we will not collide with the Fcb if the
|
|
// user wants to recreate the same file over again
|
|
// before we get a close irp.
|
|
//
|
|
// Note that we remove the name even if we couldn't
|
|
// truncate the allocation and remove the dirent above.
|
|
//
|
|
|
|
FatRemoveNames( IrpContext, Fcb );
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// We've just finished everything associated with an unclean
|
|
// fcb so now decrement the unclean count before releasing
|
|
// the resource.
|
|
//
|
|
|
|
ASSERT( Fcb->UncleanCount != 0 );
|
|
Fcb->UncleanCount -= 1;
|
|
if (!FlagOn( FileObject->Flags, FO_CACHE_SUPPORTED )) {
|
|
ASSERT( Fcb->NonCachedUncleanCount != 0 );
|
|
Fcb->NonCachedUncleanCount -= 1;
|
|
}
|
|
|
|
//
|
|
// If this was the last cached open, and there are open
|
|
// non-cached handles, attempt a flush and purge operation
|
|
// to avoid cache coherency overhead from these non-cached
|
|
// handles later. We ignore any I/O errors from the flush.
|
|
//
|
|
|
|
if (FlagOn( FileObject->Flags, FO_CACHE_SUPPORTED ) &&
|
|
(Fcb->NonCachedUncleanCount != 0) &&
|
|
(Fcb->NonCachedUncleanCount == Fcb->UncleanCount) &&
|
|
(Fcb->NonPaged->SectionObjectPointers.DataSectionObject != NULL)) {
|
|
|
|
CcFlushCache( &Fcb->NonPaged->SectionObjectPointers, NULL, 0, NULL );
|
|
|
|
//
|
|
// Grab and release PagingIo to serialize ourselves with the lazy writer.
|
|
// This will work to ensure that all IO has completed on the cached
|
|
// data and we will succesfully tear away the cache section.
|
|
//
|
|
|
|
ExAcquireResourceExclusiveLite( Fcb->Header.PagingIoResource, TRUE);
|
|
ExReleaseResourceLite( Fcb->Header.PagingIoResource );
|
|
|
|
CcPurgeCacheSection( &Fcb->NonPaged->SectionObjectPointers,
|
|
NULL,
|
|
0,
|
|
FALSE );
|
|
}
|
|
|
|
//
|
|
// If the file is invalid, hint to the cache that we should throw everything out.
|
|
//
|
|
|
|
if ( Fcb->FcbCondition == FcbBad ) {
|
|
|
|
TruncateSize = &FatLargeZero;
|
|
}
|
|
|
|
//
|
|
// Cleanup the cache map
|
|
//
|
|
|
|
CcUninitializeCacheMap( FileObject, TruncateSize, NULL );
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
FatBugCheck( TypeOfOpen, 0, 0 );
|
|
}
|
|
|
|
//
|
|
// We must clean up the share access at this time, since we may not
|
|
// get a Close call for awhile if the file was mapped through this
|
|
// File Object.
|
|
//
|
|
|
|
if (ShareAccess != NULL) {
|
|
|
|
DebugTrace(0, Dbg, "Cleanup the Share access\n", 0);
|
|
IoRemoveShareAccess( FileObject, ShareAccess );
|
|
}
|
|
|
|
if (TypeOfOpen == UserFileOpen) {
|
|
|
|
//
|
|
// Coordinate the cleanup operation with the oplock state.
|
|
// Cleanup operations can always cleanup immediately.
|
|
//
|
|
|
|
FsRtlCheckOplock( &Fcb->Specific.Fcb.Oplock,
|
|
Irp,
|
|
IrpContext,
|
|
NULL,
|
|
NULL );
|
|
|
|
Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );
|
|
}
|
|
|
|
//
|
|
// First set the FO_CLEANUP_COMPLETE flag.
|
|
//
|
|
|
|
SetFlag( FileObject->Flags, FO_CLEANUP_COMPLETE );
|
|
|
|
Status = STATUS_SUCCESS;
|
|
|
|
//
|
|
// Now unpin any repinned Bcbs.
|
|
//
|
|
|
|
FatUnpinRepinnedBcbs( IrpContext );
|
|
|
|
//
|
|
// If this was deferred flush media, flush the volume.
|
|
// We used to do this in lieu of write through for all removable
|
|
// media.
|
|
//
|
|
|
|
if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_DEFERRED_FLUSH) &&
|
|
!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_WRITE_PROTECTED)) {
|
|
|
|
//
|
|
// Flush the file.
|
|
//
|
|
|
|
if ((TypeOfOpen == UserFileOpen) &&
|
|
FlagOn(FileObject->Flags, FO_FILE_MODIFIED)) {
|
|
|
|
Status = FatFlushFile( IrpContext, Fcb, Flush );
|
|
}
|
|
|
|
//
|
|
// If that worked ok, then see if we should flush the FAT as well.
|
|
//
|
|
|
|
if (NT_SUCCESS(Status) && Fcb && !FatIsFat12( Vcb) &&
|
|
FlagOn( Fcb->FcbState, FCB_STATE_FLUSH_FAT)) {
|
|
|
|
Status = FatFlushFat( IrpContext, Vcb);
|
|
}
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
|
|
FatNormalizeAndRaiseStatus( IrpContext, Status );
|
|
}
|
|
}
|
|
|
|
} finally {
|
|
|
|
DebugUnwind( FatCommonCleanup );
|
|
|
|
if (AcquiredFcb) { FatReleaseFcb( IrpContext, Fcb ); }
|
|
if (AcquiredVcb) { FatReleaseVcb( IrpContext, Vcb ); }
|
|
|
|
if (SendUnlockNotification) {
|
|
|
|
FsRtlNotifyVolumeEvent( FileObject, FSRTL_VOLUME_UNLOCK );
|
|
}
|
|
|
|
//
|
|
// If this is a normal termination then complete the request
|
|
//
|
|
|
|
if (!AbnormalTermination()) {
|
|
|
|
FatCompleteRequest( IrpContext, Irp, Status );
|
|
}
|
|
|
|
DebugTrace(-1, Dbg, "FatCommonCleanup -> %08lx\n", Status);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
VOID
|
|
FatAutoUnlock (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
IN PVCB Vcb
|
|
)
|
|
{
|
|
KIRQL SavedIrql;
|
|
|
|
//
|
|
// Unlock the volume.
|
|
//
|
|
|
|
IoAcquireVpbSpinLock( &SavedIrql );
|
|
|
|
ClearFlag( Vcb->Vpb->Flags, VPB_LOCKED );
|
|
|
|
Vcb->VcbState &= ~VCB_STATE_FLAG_LOCKED;
|
|
Vcb->FileObjectWithVcbLocked = NULL;
|
|
|
|
IoReleaseVpbSpinLock( SavedIrql );
|
|
}
|
|
|