NTSTATUS
CdCommonCleanup (
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.
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;
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);
//
// 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( &Fcb->Oplock,
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 :
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) {
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) {
CdAcquireVcbExclusive( IrpContext, Vcb, FALSE );
try {
CdPurgeVolume( IrpContext, Vcb, FALSE );
} finally {
CdReleaseVcb( IrpContext, Vcb );
}
}
//
// If this is a normal termination then complete the request
//
CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
return STATUS_SUCCESS;
}
BOOLEAN
CdCommonClosePrivate (
IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN PFCB Fcb,
IN ULONG UserReference,
IN BOOLEAN FromFsd
)
/*++
Routine Description:
This is the worker routine for the close operation. We can be called in
an Fsd thread or from a worker Fsp thread. If called from the Fsd thread
then we acquire the resources without waiting. Otherwise we know it is
safe to wait.
We check to see whether we should post this request to the delayed close
queue. If we are to process the close here then we acquire the Vcb and
Fcb. We will adjust the counts and call our teardown routine to see
if any of the structures should go away.
Arguments:
Vcb - Vcb for this volume.
Fcb - Fcb for this request.
UserReference - Number of user references for this file object. This is
zero for an internal stream.
FromFsd - This request was called from an Fsd thread. Indicates whether
we should wait to acquire resources.
DelayedClose - Address to store whether we should try to put this on
the delayed close queue. Ignored if this routine can process this
close.
Return Value:
BOOLEAN - TRUE if this thread processed the close, FALSE otherwise.
--*/
{
BOOLEAN RemovedFcb;
PAGED_CODE();
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_FCB( Fcb );
//
// Try to acquire the Vcb and Fcb. If we can't acquire them then return
// and let our caller know he should post the request to the async
// queue.
//
if (CdAcquireVcbShared( IrpContext, Vcb, FromFsd )) {
if (!CdAcquireFcbExclusive( IrpContext, Fcb, FromFsd )) {
//
// We couldn't get the Fcb. Release the Vcb and let our caller
// know to post this request.
//
CdReleaseVcb( IrpContext, Vcb );
return FALSE;
}
//
// We didn't get the Vcb. Let our caller know to post this request.
//
} else {
return FALSE;
}
//
// Lock the Vcb and decrement the reference counts.
//
CdLockVcb( IrpContext, Vcb );
CdDecrementReferenceCounts( IrpContext, Fcb, 1, UserReference );
CdUnlockVcb( IrpContext, Vcb );
//
// Call our teardown routine to see if this object can go away.
// If we don't remove the Fcb then release it.
//
CdTeardownStructures( IrpContext, Fcb, &RemovedFcb );
if (!RemovedFcb) {
CdReleaseFcb( IrpContext, Fcb );
}
//
// Release the Vcb and return to our caller. Let him know we completed
// this request.
//
CdReleaseVcb( IrpContext, Vcb );
return TRUE;
}
VOID
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
CdOplockComplete (
_Inout_ PIRP_CONTEXT IrpContext,
_Inout_ PIRP Irp
)
/*++
Routine Description:
This routine is called by the oplock package when an oplock break has
completed, allowing an Irp to resume execution. If the status in
the Irp is STATUS_SUCCESS, then we queue the Irp to the Fsp queue.
Otherwise we complete the Irp with the status in the Irp.
If we are completing due to an error then check if there is any
cleanup to do.
Arguments:
Irp - I/O Request Packet.
Return Value:
None.
--*/
{
BOOLEAN RemovedFcb;
PAGED_CODE();
//
// Check on the return value in the Irp. If success then we
// are to post this request.
//
if (Irp->IoStatus.Status == STATUS_SUCCESS) {
//
// Check if there is any cleanup work to do.
//
switch (IrpContext->MajorFunction) {
case IRP_MJ_CREATE :
//
// If called from the oplock package then there is an
// Fcb to possibly teardown. We will call the teardown
// routine and release the Fcb if still present. The cleanup
// code in create will know not to release this Fcb because
// we will clear the pointer.
//
if (IrpContext->TeardownFcb != NULL) {
CdTeardownStructures( IrpContext, *(IrpContext->TeardownFcb), &RemovedFcb );
if (!RemovedFcb) {
_Analysis_assume_lock_held_((*IrpContext->TeardownFcb)->FcbNonpaged->FcbResource);
CdReleaseFcb( IrpContext, *(IrpContext->TeardownFcb) );
}
*(IrpContext->TeardownFcb) = NULL;
IrpContext->TeardownFcb = NULL;
}
break;
}
//
// Insert the Irp context in the workqueue.
//
CdAddToWorkque( IrpContext, Irp );
//
// Otherwise complete the request.
//
} else {
CdCompleteRequest( IrpContext, Irp, Irp->IoStatus.Status );
}
return;
}
VOID
CdFindPrefix (
_In_ PIRP_CONTEXT IrpContext,
_Inout_ PFCB *CurrentFcb,
_Inout_ PUNICODE_STRING RemainingName,
_In_ BOOLEAN IgnoreCase
)
/*++
Routine Description:
This routine begins from the given CurrentFcb and walks through all of
components of the name looking for the longest match in the prefix
splay trees. The search is relative to the starting Fcb so the
full name may not begin with a '\'. On return this routine will
update Current Fcb with the lowest point it has travelled in the
tree. It will also hold only that resource on return and it must
hold that resource.
Arguments:
CurrentFcb - Address to store the lowest Fcb we find on this search.
On return we will have acquired this Fcb. On entry this is the
Fcb to examine.
RemainingName - Supplies a buffer to store the exact case of the name being
searched for. Initially will contain the upcase name based on the
IgnoreCase flag.
IgnoreCase - Indicates if we are doing a case-insensitive compare.
Return Value:
None
--*/
{
UNICODE_STRING LocalRemainingName;
UNICODE_STRING FinalName;
PNAME_LINK NameLink;
PPREFIX_ENTRY PrefixEntry;
PAGED_CODE();
//
// Make a local copy of the input strings.
//
LocalRemainingName = *RemainingName;
//
// Loop until we find the longest matching prefix.
//
while (TRUE) {
//
// If there are no characters left or we are not at an IndexFcb then
// return immediately.
//
if ((LocalRemainingName.Length == 0) ||
(SafeNodeType( *CurrentFcb ) != CDFS_NTC_FCB_INDEX)) {
return;
}
//
// Split off the next component from the name.
//
CdDissectName( IrpContext,
&LocalRemainingName,
&FinalName );
//
// Check if this name is in the splay tree for this Scb.
//
if (IgnoreCase) {
NameLink = CdFindNameLink( IrpContext,
&(*CurrentFcb)->IgnoreCaseRoot,
&FinalName );
//
// Get the prefix entry from this NameLink. Don't access any
// fields within it until we verify we have a name link.
//
PrefixEntry = (PPREFIX_ENTRY) CONTAINING_RECORD( NameLink,
PREFIX_ENTRY,
IgnoreCaseName );
} else {
NameLink = CdFindNameLink( IrpContext,
&(*CurrentFcb)->ExactCaseRoot,
&FinalName );
PrefixEntry = (PPREFIX_ENTRY) CONTAINING_RECORD( NameLink,
PREFIX_ENTRY,
ExactCaseName );
}
//
// If we didn't find a match then exit.
//
if (NameLink == NULL) { return; }
//
// If this is a case-insensitive match then copy the exact case of the name into
// the input buffer.
//
if (IgnoreCase) {
RtlCopyMemory( FinalName.Buffer,
PrefixEntry->ExactCaseName.FileName.Buffer,
PrefixEntry->ExactCaseName.FileName.Length );
}
//
// Update the caller's remaining name string to reflect the fact that we found
// a match.
//
*RemainingName = LocalRemainingName;
//
// Move down to the next component in the tree. Acquire without waiting.
// If this fails then lock the Fcb to reference this Fcb and then drop
// the parent and acquire the child.
//
if (!CdAcquireFcbExclusive( IrpContext, PrefixEntry->Fcb, TRUE )) {
//
// If we can't wait then raise CANT_WAIT.
//
if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
CdRaiseStatus( IrpContext, STATUS_CANT_WAIT );
}
CdLockVcb( IrpContext, IrpContext->Vcb );
PrefixEntry->Fcb->FcbReference += 1;
CdUnlockVcb( IrpContext, IrpContext->Vcb );
CdReleaseFcb( IrpContext, *CurrentFcb );
CdAcquireFcbExclusive( IrpContext, PrefixEntry->Fcb, FALSE );
CdLockVcb( IrpContext, IrpContext->Vcb );
PrefixEntry->Fcb->FcbReference -= 1;
CdUnlockVcb( IrpContext, IrpContext->Vcb );
} else {
CdReleaseFcb( IrpContext, *CurrentFcb );
}
*CurrentFcb = PrefixEntry->Fcb;
}
}
VOID
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
CdPrePostIrp (
_Inout_ PIRP_CONTEXT IrpContext,
_Inout_ PIRP Irp
)
/*++
Routine Description:
This routine performs any neccessary work before STATUS_PENDING is
returned with the Fsd thread. This routine is called within the
filesystem and by the oplock package.
Arguments:
Context - Pointer to the IrpContext to be queued to the Fsp
Irp - I/O Request Packet.
Return Value:
None.
--*/
{
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
BOOLEAN RemovedFcb;
PAGED_CODE();
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_IRP( Irp );
//
// Case on the type of the operation.
//
switch (IrpContext->MajorFunction) {
case IRP_MJ_CREATE :
//
// If called from the oplock package then there is an
// Fcb to possibly teardown. We will call the teardown
// routine and release the Fcb if still present. The cleanup
// code in create will know not to release this Fcb because
// we will clear the pointer.
//
if ((IrpContext->TeardownFcb != NULL) &&
*(IrpContext->TeardownFcb) != NULL) {
CdTeardownStructures( IrpContext, *(IrpContext->TeardownFcb), &RemovedFcb );
if (!RemovedFcb) {
_Analysis_assume_lock_held_((*IrpContext->TeardownFcb)->FcbNonpaged->FcbResource);
CdReleaseFcb( IrpContext, *(IrpContext->TeardownFcb) );
}
*(IrpContext->TeardownFcb) = NULL;
IrpContext->TeardownFcb = NULL;
}
break;
//
// We need to lock the user's buffer, unless this is an MDL read/write,
// in which case there is no user buffer.
//
case IRP_MJ_READ :
if (!FlagOn( IrpContext->MinorFunction, IRP_MN_MDL )) {
CdLockUserBuffer( IrpContext, IrpSp->Parameters.Read.Length, IoWriteAccess );
}
break;
case IRP_MJ_WRITE :
if (!FlagOn( IrpContext->MinorFunction, IRP_MN_MDL )) {
CdLockUserBuffer( IrpContext, IrpSp->Parameters.Read.Length, IoReadAccess );
}
break;
//
// We also need to check whether this is a query file operation.
//
case IRP_MJ_DIRECTORY_CONTROL :
if (IrpContext->MinorFunction == IRP_MN_QUERY_DIRECTORY) {
CdLockUserBuffer( IrpContext, IrpSp->Parameters.QueryDirectory.Length, IoWriteAccess );
}
break;
}
//
// Cleanup the IrpContext for the post.
//
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
CdCleanupIrpContext( IrpContext, TRUE );
//
// Mark the Irp to show that we've already returned pending to the user.
//
IoMarkIrpPending( Irp );
return;
}