NTSTATUS
CdCommonCleanup (
_Inout_ PIRP_CONTEXT IrpContext,
_Inout_ 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.
We do no synchronization in this routine until we get to the point
where we modify the counts, share access and volume lock field.
We need to update the Fcb and Vcb to show that a user handle has been closed.
The following structures and fields are affected.
Vcb:
VolumeLockFileObject - Did the user lock the volume with this file object.
VcbState - Check if we are unlocking the volume here.
VcbCleanup - Count of outstanding handles on the volume.
DirNotifyQueue - If this file object has pending DirNotify Irps.
Fcb:
ShareAccess - If this is a user handle.
FcbCleanup - Count of outstanding handles on this Fcb.
Oplock - Any outstanding oplocks on this file object.
FileLock - Any outstanding filelocks on this file object.
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation.
--*/
{
PFILE_OBJECT FileObject;
TYPE_OF_OPEN TypeOfOpen;
BOOLEAN SendUnlockNotification = FALSE;
BOOLEAN AttemptTeardown = FALSE;
BOOLEAN VcbAcquired = FALSE;
PVCB Vcb;
PFCB Fcb;
PCCB Ccb;
KIRQL SavedIrql;
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
//
// If we were called with our file system device object instead of a
// volume device object, just complete this request with STATUS_SUCCESS.
//
if (IrpContext->Vcb == NULL) {
CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
return STATUS_SUCCESS;
}
//
// Get the file object out of the Irp and decode the type of open.
//
FileObject = IoGetCurrentIrpStackLocation( Irp )->FileObject;
TypeOfOpen = CdDecodeFileObject( IrpContext,
FileObject,
&Fcb,
&Ccb );
//
// No work here for either an UnopenedFile object or a StreamFileObject.
//
if (TypeOfOpen <= StreamFileOpen) {
CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
return STATUS_SUCCESS;
}
//
// Keep a local pointer to the Vcb.
//
Vcb = Fcb->Vcb;
//
// Synchronise with reads while we set the cleanup complete
// flag on this fileobject. Once this flag is set, any further
// reads will be rejected (CdVerifyFcbOperation)
//
CdAcquireFileExclusive( IrpContext, Fcb);
//
// Set the flag in the FileObject to indicate that cleanup is complete.
//
SetFlag( FileObject->Flags, FO_CLEANUP_COMPLETE );
CdReleaseFile( IrpContext, Fcb);
if (TypeOfOpen == UserVolumeOpen) {
//
// For a force dismount, physically disconnect this Vcb from the device so
// a new mount can occur. Vcb deletion cannot happen at this time since
// there is a reference on it associated with this very request, but we'll
// call check for dismount again later after we process this close.
//
if (FlagOn( Ccb->Flags, CCB_FLAG_DISMOUNT_ON_CLOSE )) {
CdAcquireCdData( IrpContext );
CdCheckForDismount( IrpContext, Vcb, TRUE );
CdReleaseCdData( IrpContext );
//
// If this handle 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 (FlagOn( FileObject->Flags, FO_FILE_MODIFIED )) {
CdHijackIrpAndFlushDevice( IrpContext, Irp, Vcb->TargetDeviceObject );
CdMarkDevForVerifyIfVcbMounted( Vcb );
}
}
//
// Acquire the current file.
//
CdAcquireFcbExclusive( IrpContext, Fcb, FALSE );
//
// Use a try-finally to facilitate cleanup.
//
try {
//
// Case on the type of open that we are trying to cleanup.
//
switch (TypeOfOpen) {
case UserDirectoryOpen:
//
// Check if we need to complete any dir notify Irps on this file object.
//
FsRtlNotifyCleanup( Vcb->NotifySync,
&Vcb->DirNotifyList,
Ccb );
break;
case UserFileOpen:
//
// Coordinate the cleanup operation with the oplock state.
// Oplock cleanup operations can always cleanup immediately so no
// need to check for STATUS_PENDING.
//
FsRtlCheckOplock( CdGetFcbOplock(Fcb),
Irp,
IrpContext,
NULL,
NULL );
//
// Unlock all outstanding file locks.
//
if (Fcb->FileLock != NULL) {
FsRtlFastUnlockAll( Fcb->FileLock,
FileObject,
IoGetRequestorProcess( Irp ),
NULL );
}
//
// Cleanup the cache map.
//
CcUninitializeCacheMap( FileObject, NULL, NULL );
//
// Check the fast io state.
//
CdLockFcb( IrpContext, Fcb );
Fcb->IsFastIoPossible = CdIsFastIoPossible( Fcb );
CdUnlockFcb( IrpContext, Fcb );
break;
case UserVolumeOpen:
break;
default :
#pragma prefast( suppress:__WARNING_USE_OTHER_FUNCTION, "argument bogus" )
CdBugCheck( TypeOfOpen, 0, 0 );
}
//
// Now lock the Vcb in order to modify the fields in the in-memory
// structures.
//
CdLockVcb( IrpContext, Vcb );
//
// Decrement the cleanup counts in the Vcb and Fcb.
//
CdDecrementCleanupCounts( IrpContext, Fcb );
//
// If the cleanup count hit zero and the volume is not mounted, we
// will want to try to spark teardown.
//
AttemptTeardown = (Vcb->VcbCleanup == 0 && Vcb->VcbCondition == VcbNotMounted);
//
// If this file object has locked the volume then perform the unlock operation.
// We do this regardless of explicit or implicit (no share DASD open) lock.
//
if (FileObject == Vcb->VolumeLockFileObject) {
NT_ASSERT( FlagOn( Vcb->VcbState, VCB_STATE_LOCKED));
IoAcquireVpbSpinLock( &SavedIrql );
ClearFlag( Vcb->Vpb->Flags, VPB_LOCKED);
ClearFlag( Vcb->VcbState, VCB_STATE_LOCKED );
Vcb->VolumeLockFileObject = NULL;
SendUnlockNotification = TRUE;
IoReleaseVpbSpinLock( SavedIrql );
}
CdUnlockVcb( IrpContext, Vcb );
//
// 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.
//
IoRemoveShareAccess( FileObject, &Fcb->ShareAccess );
} finally {
CdReleaseFcb( IrpContext, Fcb );
if (SendUnlockNotification) {
FsRtlNotifyVolumeEvent( FileObject, FSRTL_VOLUME_UNLOCK );
}
}
//
// If appropriate, try to spark teardown by purging the volume. Should
// this very fileobject we were cleaning up be the last reason for the
// volume to remain, teardown will commence on completion of this Irp.
//
if (AttemptTeardown) {
//
// Preacquire CdData here, since the purges will generate closes which
// may acquire CdData if there is a possibility of tearing the volume
// down.
//
CdAcquireCdData( IrpContext);
try {
CdAcquireVcbExclusive( IrpContext, Vcb, FALSE );
VcbAcquired = TRUE;
CdPurgeVolume( IrpContext, Vcb, FALSE );
} finally {
if (VcbAcquired) { CdReleaseVcb( IrpContext, Vcb ); }
CdReleaseCdData( IrpContext);
}
}
//
// If this is a normal termination then complete the request
//
CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
return STATUS_SUCCESS;
}
NTSTATUS
CdCommonLockControl (
_Inout_ PIRP_CONTEXT IrpContext,
_Inout_ PIRP Irp
)
/*++
Routine Description:
This is the common routine for Lock Control 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 = IoGetCurrentIrpStackLocation( Irp );
TYPE_OF_OPEN TypeOfOpen;
PFCB Fcb;
PCCB Ccb;
PAGED_CODE();
//
// Extract and decode the type of file object we're being asked to process
//
TypeOfOpen = CdDecodeFileObject( IrpContext, IrpSp->FileObject, &Fcb, &Ccb );
//
// If the file is not a user file open then we reject the request
// as an invalid parameter
//
if (TypeOfOpen != UserFileOpen) {
CdCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
return STATUS_INVALID_PARAMETER;
}
//
// We check whether we can proceed based on the state of the file oplocks.
// This call might post the irp for us.
//
Status = FsRtlCheckOplock( CdGetFcbOplock(Fcb),
Irp,
IrpContext,
CdOplockComplete,
NULL );
//
// If we don't get success then the oplock package completed the request.
//
if (Status != STATUS_SUCCESS) {
return Status;
}
//
// Verify the Fcb.
//
CdVerifyFcbOperation( IrpContext, Fcb );
//
// If we don't have a file lock, then get one now.
//
if (Fcb->FileLock == NULL) { CdCreateFileLock( IrpContext, Fcb, TRUE ); }
//
// Now call the FsRtl routine to do the actual processing of the
// Lock request
//
Status = FsRtlProcessFileLock( Fcb->FileLock, Irp, NULL );
//
// Set the flag indicating if Fast I/O is possible
//
CdLockFcb( IrpContext, Fcb );
Fcb->IsFastIoPossible = CdIsFastIoPossible( Fcb );
CdUnlockFcb( IrpContext, Fcb );
//
// Complete the request.
//
CdCompleteRequest( IrpContext, NULL, Status );
return Status;
}
BOOLEAN
CdFastUnlockAllByKey (
_In_ PFILE_OBJECT FileObject,
_In_ PVOID ProcessId,
_In_ ULONG Key,
_Out_ PIO_STATUS_BLOCK IoStatus,
_In_ PDEVICE_OBJECT DeviceObject
)
/*++
Routine Description:
This is a call back routine for doing the fast unlock all by key call.
Arguments:
FileObject - Supplies the file object used in this operation
ProcessId - Supplies the process ID used in this operation
Key - Supplies the key used in this operation
Status - Receives the Status if this operation is successful
Return Value:
BOOLEAN - TRUE if this operation completed and FALSE if caller
needs to take the long route.
--*/
{
BOOLEAN Results = FALSE;
TYPE_OF_OPEN TypeOfOpen;
PFCB Fcb;
PAGED_CODE();
UNREFERENCED_PARAMETER( DeviceObject );
IoStatus->Information = 0;
//
// Decode the type of file object we're being asked to process and
// make sure that is is only a user file open.
//
TypeOfOpen = CdFastDecodeFileObject( FileObject, &Fcb );
if (TypeOfOpen != UserFileOpen) {
IoStatus->Status = STATUS_INVALID_PARAMETER;
return TRUE;
}
//
// Only deal with 'good' Fcb's.
//
if (!CdVerifyFcbOperation( NULL, Fcb )) {
return FALSE;
}
//
// If there is no lock then return immediately.
//
if (Fcb->FileLock == NULL) {
IoStatus->Status = STATUS_RANGE_NOT_LOCKED;
return TRUE;
}
FsRtlEnterFileSystem();
try {
//
// We check whether we can proceed based on the state of the file oplocks.
//
if (!FsRtlOplockIsFastIoPossible( CdGetFcbOplock(Fcb) )) {
try_return( NOTHING );
}
//
// If we don't have a file lock, then get one now.
//
if ((Fcb->FileLock == NULL) && !CdCreateFileLock( NULL, Fcb, FALSE )) {
try_return( NOTHING );
}
//
// Now call the FsRtl routine to do the actual processing of the
// Lock request. The call will always succeed.
//
Results = TRUE;
IoStatus->Status = FsRtlFastUnlockAllByKey( Fcb->FileLock,
FileObject,
ProcessId,
Key,
NULL );
//
// Set the flag indicating if Fast I/O is possible
//
CdLockFcb( IrpContext, Fcb );
Fcb->IsFastIoPossible = CdIsFastIoPossible( Fcb );
CdUnlockFcb( IrpContext, Fcb );
try_exit: NOTHING;
} finally {
FsRtlExitFileSystem();
}
return Results;
}
BOOLEAN
CdFastLock (
_In_ PFILE_OBJECT FileObject,
_In_ PLARGE_INTEGER FileOffset,
_In_ PLARGE_INTEGER Length,
_In_ PEPROCESS ProcessId,
_In_ ULONG Key,
_In_ BOOLEAN FailImmediately,
_In_ BOOLEAN ExclusiveLock,
_Out_ PIO_STATUS_BLOCK IoStatus,
_In_ PDEVICE_OBJECT DeviceObject
)
/*++
Routine Description:
This is a call back routine for doing the fast lock call.
Arguments:
FileObject - Supplies the file object used in this operation
FileOffset - Supplies the file offset used in this operation
Length - Supplies the length used in this operation
ProcessId - Supplies the process ID used in this operation
Key - Supplies the key used in this operation
FailImmediately - Indicates if the request should fail immediately
if the lock cannot be granted.
ExclusiveLock - Indicates if this is a request for an exclusive or
shared lock
IoStatus - Receives the Status if this operation is successful
Return Value:
BOOLEAN - TRUE if this operation completed and FALSE if caller
needs to take the long route.
--*/
{
BOOLEAN Results = FALSE;
PFCB Fcb;
TYPE_OF_OPEN TypeOfOpen;
PAGED_CODE();
UNREFERENCED_PARAMETER( DeviceObject );
ASSERT_FILE_OBJECT( FileObject );
IoStatus->Information = 0;
//
// Decode the type of file object we're being asked to process and
// make sure that is is only a user file open.
//
TypeOfOpen = CdFastDecodeFileObject( FileObject, &Fcb );
if (TypeOfOpen != UserFileOpen) {
IoStatus->Status = STATUS_INVALID_PARAMETER;
return TRUE;
}
//
// Only deal with 'good' Fcb's.
//
if (!CdVerifyFcbOperation( NULL, Fcb )) {
return FALSE;
}
FsRtlEnterFileSystem();
//
// Use a try-finally to facilitate cleanup.
//
try {
//
// We check whether we can proceed based on the state of the file oplocks.
//
if (!FsRtlOplockIsFastIoPossible( CdGetFcbOplock(Fcb) )) {
try_return( NOTHING );
}
//
// If we don't have a file lock, then get one now.
//
if ((Fcb->FileLock == NULL) && !CdCreateFileLock( NULL, Fcb, FALSE )) {
try_return( NOTHING );
}
//
// Now call the FsRtl routine to perform the lock request.
//
#pragma prefast(suppress: 28159, "prefast thinks this is an obsolete routine, but it is ok for CDFS to use it")
if ((Results = FsRtlFastLock( Fcb->FileLock,
FileObject,
FileOffset,
Length,
ProcessId,
Key,
FailImmediately,
ExclusiveLock,
IoStatus,
NULL,
FALSE )) != FALSE) {
//
// Set the flag indicating if Fast I/O is questionable. We
// only change this flag if the current state is possible.
// Retest again after synchronizing on the header.
//
if (Fcb->IsFastIoPossible == FastIoIsPossible) {
CdLockFcb( NULL, Fcb );
Fcb->IsFastIoPossible = CdIsFastIoPossible( Fcb );
CdUnlockFcb( NULL, Fcb );
}
}
try_exit: NOTHING;
} finally {
FsRtlExitFileSystem();
}
return Results;
}
