/*
* @implemented
*/
VOID
NTAPI
IopDereferenceVpbAndFree(IN PVPB Vpb)
{
KIRQL OldIrql;
/* Lock the VPBs and decrease references */
IoAcquireVpbSpinLock(&OldIrql);
Vpb->ReferenceCount--;
/* Check if we're out of references */
if (!Vpb->ReferenceCount && Vpb->RealDevice->Vpb == Vpb &&
!(Vpb->Flags & VPB_PERSISTENT))
{
/* Release VPB lock */
IoReleaseVpbSpinLock(OldIrql);
/* And free VPB */
ExFreePoolWithTag(Vpb, TAG_VPB);
}
else
{
/* Release VPB lock */
IoReleaseVpbSpinLock(OldIrql);
}
}
/*
* @implemented
*/
BOOLEAN
NTAPI
IopReferenceVerifyVpb(IN PDEVICE_OBJECT DeviceObject,
OUT PDEVICE_OBJECT *FileSystemObject,
OUT PVPB *Vpb)
{
KIRQL OldIrql;
PVPB LocalVpb;
BOOLEAN Result = FALSE;
/* Lock the VPBs and assume failure */
IoAcquireVpbSpinLock(&OldIrql);
*Vpb = NULL;
*FileSystemObject = NULL;
/* Get the VPB and make sure it's mounted */
LocalVpb = DeviceObject->Vpb;
if ((LocalVpb) && (LocalVpb->Flags & VPB_MOUNTED))
{
/* Return it */
*Vpb = LocalVpb;
*FileSystemObject = LocalVpb->DeviceObject;
/* Reference it */
LocalVpb->ReferenceCount++;
Result = TRUE;
}
/* Release the VPB lock and return status */
IoReleaseVpbSpinLock(OldIrql);
return Result;
}
PVPB
NTAPI
IopMountInitializeVpb(IN PDEVICE_OBJECT DeviceObject,
IN PDEVICE_OBJECT AttachedDeviceObject,
IN BOOLEAN Raw)
{
KIRQL OldIrql;
PVPB Vpb;
/* Lock the VPBs */
IoAcquireVpbSpinLock(&OldIrql);
Vpb = DeviceObject->Vpb;
/* Set the VPB as mounted and possibly raw */
Vpb->Flags |= VPB_MOUNTED | (Raw ? VPB_RAW_MOUNT : 0);
/* Set the stack size */
Vpb->DeviceObject->StackSize = AttachedDeviceObject->StackSize;
/* Add one for the FS Driver */
Vpb->DeviceObject->StackSize++;
/* Set the VPB in the device extension */
IoGetDevObjExtension(Vpb->DeviceObject)->Vpb = Vpb;
/* Reference it */
Vpb->ReferenceCount++;
/* Release the VPB lock and return it */
IoReleaseVpbSpinLock(OldIrql);
return Vpb;
}
VOID
FatPnpAdjustVpbRefCount(
IN PVCB Vcb,
IN ULONG Delta
)
{
KIRQL OldIrql;
IoAcquireVpbSpinLock( &OldIrql);
Vcb->Vpb->ReferenceCount += Delta;
IoReleaseVpbSpinLock( OldIrql);
}
VOID
FFSSetVpbFlag(
IN PVPB Vpb,
IN USHORT Flag)
{
KIRQL OldIrql;
IoAcquireVpbSpinLock(&OldIrql);
Vpb->Flags |= Flag;
IoReleaseVpbSpinLock(OldIrql);
}
VOID
RfsdClearVpbFlag (
IN PVPB Vpb,
IN USHORT Flag )
{
KIRQL OldIrql;
IoAcquireVpbSpinLock(&OldIrql);
Vpb->Flags &= ~Flag;
IoReleaseVpbSpinLock(OldIrql);
}
BOOLEAN
CdMarkDevForVerifyIfVcbMounted(
IN PVCB Vcb
)
/*++
Routine Description:
This routine checks to see if the specified Vcb is currently mounted on
the device or not. If it is, it sets the verify flag on the device, if
not then the state is noted in the Vcb.
Arguments:
Vcb - This is the volume to check.
Return Value:
TRUE if the device has been marked for verify here, FALSE otherwise.
--*/
{
BOOLEAN Marked = FALSE;
KIRQL SavedIrql;
IoAcquireVpbSpinLock( &SavedIrql );
if (Vcb->Vpb->RealDevice->Vpb == Vcb->Vpb) {
CdMarkRealDevForVerify( Vcb->Vpb->RealDevice);
Marked = TRUE;
}
else {
//
// Flag this to avoid the VPB spinlock in future passes.
//
SetFlag( Vcb->VcbState, VCB_STATE_VPB_NOT_ON_DEVICE);
}
IoReleaseVpbSpinLock( SavedIrql );
return Marked;
}
BOOLEAN
CdCheckForDismount (
IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN BOOLEAN Force
)
/*++
Routine Description:
This routine is called to check if a volume is ready for dismount. This
occurs when only file system references are left on the volume.
If the dismount is not currently underway and the user reference count
has gone to zero then we can begin the dismount.
If the dismount is in progress and there are no references left on the
volume (we check the Vpb for outstanding references as well to catch
any create calls dispatched to the file system) then we can delete
the Vcb.
Arguments:
Vcb - Vcb for the volume to try to dismount.
Force - Whether we will force this volume to be dismounted.
Return Value:
BOOLEAN - True if the Vcb was not gone by the time this function finished,
False if it was deleted.
This is only a trustworthy indication to the caller if it had the vcb
exclusive itself.
--*/
{
BOOLEAN UnlockVcb = TRUE;
BOOLEAN VcbPresent = TRUE;
KIRQL SavedIrql;
ASSERT_IRP_CONTEXT( IrpContext );
ASSERT_VCB( Vcb );
ASSERT_EXCLUSIVE_CDDATA;
//
// Acquire and lock this Vcb to check the dismount state.
//
CdAcquireVcbExclusive( IrpContext, Vcb, FALSE );
//
// Lets get rid of any pending closes for this volume.
//
CdFspClose( Vcb );
CdLockVcb( IrpContext, Vcb );
//
// If the dismount is not already underway then check if the
// user reference count has gone to zero or we are being forced
// to disconnect. If so start the teardown on the Vcb.
//
if (Vcb->VcbCondition != VcbDismountInProgress) {
if (Vcb->VcbUserReference <= CDFS_RESIDUAL_USER_REFERENCE || Force) {
CdUnlockVcb( IrpContext, Vcb );
UnlockVcb = FALSE;
VcbPresent = CdDismountVcb( IrpContext, Vcb );
}
//
// If the teardown is underway and there are absolutely no references
// remaining then delete the Vcb. References here include the
// references in the Vcb and Vpb.
//
} else if (Vcb->VcbReference == 0) {
IoAcquireVpbSpinLock( &SavedIrql );
//
// If there are no file objects and no reference counts in the
// Vpb we can delete the Vcb. Don't forget that we have the
// last reference in the Vpb.
//
if (Vcb->Vpb->ReferenceCount == 1) {
IoReleaseVpbSpinLock( SavedIrql );
CdUnlockVcb( IrpContext, Vcb );
UnlockVcb = FALSE;
CdDeleteVcb( IrpContext, Vcb );
VcbPresent = FALSE;
} else {
IoReleaseVpbSpinLock( SavedIrql );
}
}
//
// Unlock the Vcb if still held.
//
if (UnlockVcb) {
CdUnlockVcb( IrpContext, Vcb );
}
//
// Release any resources still acquired.
//
if (VcbPresent) {
CdReleaseVcb( IrpContext, Vcb );
}
return VcbPresent;
}
NTSTATUS
XixFsdCommonCleanUp(
IN PXIFS_IRPCONTEXT pIrpContext
)
{
NTSTATUS RC = STATUS_SUCCESS;
PXIFS_FCB pFCB = NULL;
PXIFS_CCB pCCB = NULL;
PXIFS_VCB pVCB = NULL;
PFILE_OBJECT pFileObject = NULL;
TYPE_OF_OPEN TypeOfOpen = UnopenedFileObject;
PIRP pIrp = NULL;
PIO_STACK_LOCATION pIrpSp = NULL;
KIRQL SavedIrql;
PXIFS_LCB pLCB = NULL;
PXIFS_FCB pParentFCB = NULL;
BOOLEAN Wait = FALSE;
BOOLEAN VCBAcquired = FALSE;
BOOLEAN ParentFCBAcquired = FALSE;
BOOLEAN CanWait = FALSE;
BOOLEAN AttemptTeardown = FALSE;
BOOLEAN SendUnlockNotification = FALSE;
PAGED_CODE();
DebugTrace((DEBUG_LEVEL_TRACE), (DEBUG_TARGET_CLEANUP|DEBUG_TARGET_IRPCONTEXT),
("Enter XifsdCommonCleanUp pIrpContext(%p)\n", pIrpContext));
ASSERT_IRPCONTEXT(pIrpContext);
pIrp = pIrpContext->Irp;
ASSERT(pIrp);
// check if open request is releated to file system CDO
{
PDEVICE_OBJECT DeviceObject = pIrpContext->TargetDeviceObject;
ASSERT(DeviceObject);
if (DeviceObject == XiGlobalData.XifsControlDeviceObject) {
RC = STATUS_SUCCESS;
DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_CLEANUP),
("CDO Device TargetDevide(%p).\n", DeviceObject));
XixFsdCompleteRequest(pIrpContext,RC,0);
return(RC);
}
}
if(pIrpContext->VCB == NULL){
DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CLEANUP,
("pIrpContext->VCB == NULL.\n"));
RC = STATUS_SUCCESS;
XixFsdCompleteRequest(pIrpContext, RC, 0);
return RC;
}
pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
ASSERT(pIrpSp);
pFileObject = pIrpSp->FileObject;
ASSERT(pFileObject);
TypeOfOpen = XixFsdDecodeFileObject(pFileObject, &pFCB, &pCCB);
if(TypeOfOpen <= StreamFileOpen){
DebugTrace((DEBUG_LEVEL_TRACE|DEBUG_LEVEL_INFO), DEBUG_TARGET_CLEANUP,
("TypeOfOpen <= StreamFileOpen.\n"));
XixFsdCompleteRequest(pIrpContext, STATUS_SUCCESS, 0);
return STATUS_SUCCESS;
}
CanWait = XifsdCheckFlagBoolean(pIrpContext->IrpContextFlags, XIFSD_IRP_CONTEXT_WAIT);
if(CanWait == FALSE){
DebugTrace((DEBUG_LEVEL_TRACE|DEBUG_LEVEL_INFO), (DEBUG_TARGET_CLEANUP| DEBUG_TARGET_IRPCONTEXT),
("PostRequest IrpCxt(%p) Irp(%p)\n", pIrpContext, pIrp));
RC = XixFsdPostRequest(pIrpContext, pIrp);
return RC;
}
ASSERT_FCB(pFCB);
pVCB = pFCB->PtrVCB;
ASSERT_VCB(pVCB);
DebugTrace(DEBUG_LEVEL_CRITICAL, (DEBUG_TARGET_CLEANUP| DEBUG_TARGET_RESOURCE|DEBUG_TARGET_VCB),
("Acquire exclusive pVCB(%p) VCBResource(%p).\n", pVCB, &pVCB->VCBResource));
if((TypeOfOpen == UserVolumeOpen)
&& XifsdCheckFlagBoolean(pFileObject->Flags, FO_FILE_MODIFIED))
{
XifsdAcquireVcbExclusive(CanWait, pVCB, FALSE);
VCBAcquired = TRUE;
}
XifsdAcquireFcbExclusive(CanWait, pFCB, FALSE);
DebugTrace(DEBUG_LEVEL_CRITICAL, (DEBUG_TARGET_CLEANUP| DEBUG_TARGET_RESOURCE| DEBUG_TARGET_FCB),
("Acquire exclusive FCB(%p) FCBResource(%p).\n", pFCB, pFCB->FCBResource));
XifsdSetFlag(pFileObject->Flags, FO_CLEANUP_COMPLETE);
DebugTrace(DEBUG_LEVEL_CRITICAL, (DEBUG_TARGET_CLEANUP| DEBUG_TARGET_RESOURCE| DEBUG_TARGET_FCB),
("Set File Object Flags(0x%x)\n", pFileObject->Flags));
//IoRemoveShareAccess( pFileObject, &pFCB->FCBShareAccess );
try{
switch(TypeOfOpen){
case UserDirectoryOpen:
if(XifsdCheckFlagBoolean(pCCB->CCBFlags, XIFSD_CCB_FLAG_NOFITY_SET))
{
DebugTrace(DEBUG_LEVEL_CRITICAL, DEBUG_TARGET_ALL,
("CompletionFilter Notify CleanUp (%wZ) pCCB(%p)\n", &pFCB->FCBName, pCCB));
FsRtlNotifyCleanup(pVCB->NotifyIRPSync, &pVCB->NextNotifyIRP, pCCB);
//DbgPrint("Notify CleanUp (%wZ) pCCB(%p)\n", &pFCB->FCBName, pCCB);
}
//DbgPrint("CleanUp (%wZ) pCCB(%p) pCCB->CCBFlags(%x)\n", &pFCB->FCBName, pCCB, pCCB->CCBFlags);
DebugTrace(DEBUG_LEVEL_CRITICAL, DEBUG_TARGET_ALL,
("!!!!CleanUp (%wZ) pCCB(%p)\n", &pFCB->FCBName, pCCB));
IoRemoveShareAccess( pFileObject, &pFCB->FCBShareAccess );
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( &pFCB->FCBOplock,
pIrp,
pIrpContext,
NULL,
NULL );
//
// Unlock all outstanding file locks.
//
if (pFCB->FCBFileLock != NULL) {
FsRtlFastUnlockAll( pFCB->FCBFileLock,
pFileObject,
IoGetRequestorProcess( pIrp ),
NULL );
}
//
// Check the fast io state.
//
XifsdLockFcb( pIrpContext, pFCB );
pFCB->IsFastIoPossible = XixFsdCheckFastIoPossible( pFCB );
XifsdUnlockFcb( pIrpContext, pFCB );
/*
if((pFCB->HasLock != FCB_FILE_LOCK_HAS)
&& (!XifsdCheckFlagBoolean(pFCB->FCBFlags, XIFSD_FCB_OPEN_WRITE))
&& XifsdCheckFlagBoolean(pFileObject->Flags, FO_CACHE_SUPPORTED)
&& (pFCB->FCBCleanup == 1)
){
if(pFCB->SectionObject.DataSectionObject != NULL)
{
CcFlushCache(&(pFCB->SectionObject), NULL, 0, NULL);
ExAcquireResourceSharedLite(pFCB->PagingIoResource, TRUE);
ExReleaseResourceLite( pFCB->PagingIoResource );
CcPurgeCacheSection( &(pFCB->SectionObject),
NULL,
0,
FALSE
);
}
}
*/
if(
XifsdCheckFlagBoolean(pFileObject->Flags, FO_CACHE_SUPPORTED) &&
(pFCB->FcbNonCachedOpenCount > 1) &&
((pFCB->FcbNonCachedOpenCount + 1) == pFCB->FCBCleanup)
)
{
if(pFCB->SectionObject.DataSectionObject != NULL)
{
// changed by ILGU HONG for readonly 09052006
if(!pFCB->PtrVCB->IsVolumeWriteProctected)
CcFlushCache(&(pFCB->SectionObject), NULL, 0, NULL);
// changed by ILGU HONG for readonly end
//DbgPrint("CcFlush 1 File(%wZ)\n", &pFCB->FCBFullPath);
ExAcquireResourceSharedLite(pFCB->PagingIoResource, TRUE);
ExReleaseResourceLite( pFCB->PagingIoResource );
CcPurgeCacheSection( &(pFCB->SectionObject),
NULL,
0,
FALSE
);
}
}
/*
else if(pFCB->FCBCleanup == 1 ){
if(XifsdCheckFlagBoolean(pFileObject->Flags, FO_CACHE_SUPPORTED)){
if(pFCB->SectionObject.DataSectionObject != NULL)
{
CcFlushCache(&(pFCB->SectionObject), NULL, 0, NULL);
ExAcquireResourceSharedLite(pFCB->PagingIoResource, TRUE);
ExReleaseResourceLite( pFCB->PagingIoResource );
CcPurgeCacheSection( &(pFCB->SectionObject),
NULL,
0,
FALSE
);
}
}
if(XifsdCheckFlagBoolean(pFCB->FCBFlags,XIFSD_FCB_MODIFIED_FILE)){
XixFsdUpdateFCB(pFCB);
}
}
*/
IoRemoveShareAccess( pFileObject, &pFCB->FCBShareAccess );
//
// Cleanup the cache map.
//
CcUninitializeCacheMap( pFileObject, NULL, NULL );
break;
case UserVolumeOpen:
break;
default:
break;
}
if((TypeOfOpen == UserDirectoryOpen) || (TypeOfOpen == UserFileOpen)){
if(pFCB->FCBCleanup == 1 ){
if(XifsdCheckFlagBoolean(pFCB->FCBFlags,XIFSD_FCB_MODIFIED_FILE)){
// changed by ILGU HONG for readonly 09052006
if(!pFCB->PtrVCB->IsVolumeWriteProctected){
XixFsdUpdateFCB(pFCB);
if(pFCB->WriteStartOffset != -1){
//DbgPrint("Set Update Information!!!\n");
XixFsdSendFileChangeRC(
TRUE,
pVCB->HostMac,
pFCB->LotNumber,
pVCB->DiskId,
pVCB->PartitionId,
pFCB->FileSize.QuadPart,
pFCB->RealAllocationSize,
pFCB->WriteStartOffset
);
pFCB->WriteStartOffset = -1;
}
}
// changed by ILGU HONG for readonly end
}
}
if(XifsdCheckFlagBoolean(pCCB->CCBFlags, XIFSD_CCB_FLAGS_DELETE_ON_CLOSE)){
if(pFCB == pFCB->PtrVCB->RootDirFCB){
XifsdClearFlag(pCCB->CCBFlags, XIFSD_CCB_FLAGS_DELETE_ON_CLOSE);
XifsdClearFlag(pFCB->FCBFlags, XIFSD_FCB_DELETE_ON_CLOSE);
}else{
XifsdSetFlag(pFCB->FCBFlags, XIFSD_FCB_DELETE_ON_CLOSE);
}
}
// changed by ILGU HONG for readonly 09082006
if(XifsdCheckFlagBoolean(pFCB->FCBFlags, XIFSD_FCB_DELETE_ON_CLOSE) && (!pFCB->PtrVCB->IsVolumeWriteProctected) ){
// changed by ILGU HONG for readonly end
if(pFCB->FCBCleanup == 1){
//DbgPrint(" !!!Delete Entry From table (%wZ) .\n", &pFCB->FCBFullPath);
ASSERT_CCB(pCCB);
pLCB = pCCB->PtrLCB;
ASSERT_LCB(pLCB);
pParentFCB = pLCB->ParentFcb;
ASSERT_FCB(pParentFCB);
pFCB->FileSize.QuadPart = 0;
pFCB->ValidDataLength.QuadPart = 0;
if(pFCB->FCBType == FCB_TYPE_FILE){
XifsdReleaseFcb(TRUE, pFCB);
XifsdAcquireFcbExclusive(TRUE, pParentFCB, FALSE);
ParentFCBAcquired = TRUE;
XifsdAcquireFcbExclusive(TRUE, pFCB, FALSE);
RC = DeleteParentChild(pIrpContext, pParentFCB, &pLCB->FileName);
if(!NT_SUCCESS(RC)){
DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL,
("Fail DeleteParentChild (%wZ)\n", &pLCB->FileName));
//XifsdClearFlag(pFCB->FCBFlags, XIFSD_FCB_DELETE_ON_CLOSE);
RC = STATUS_SUCCESS;
goto pass_through;
}
XifsdClearFlag(pLCB->LCBFlags, XIFSD_LCB_STATE_DELETE_ON_CLOSE);
XifsdSetFlag(pLCB->LCBFlags, XIFSD_LCB_STATE_LINK_IS_GONE);
XixFsdRemovePrefix(TRUE, pLCB);
//
// Now Decrement the reference counts for the parent and drop the Vcb.
//
XifsdLockVcb(pIrpContext,pVCB);
DebugTrace( DEBUG_LEVEL_INFO, (DEBUG_TARGET_FILEINFO|DEBUG_TARGET_FCB|DEBUG_TARGET_REFCOUNT),
("XifsdSetRenameInformation, PFcb (%I64d) Vcb %d/%d Fcb %d/%d\n",
pParentFCB->LotNumber,
pVCB->VCBReference,
pVCB->VCBUserReference,
pParentFCB->FCBReference,
pParentFCB->FCBUserReference ));
XifsdDecRefCount( pParentFCB, 1, 1 );
DebugTrace( DEBUG_LEVEL_CRITICAL, (DEBUG_TARGET_FILEINFO|DEBUG_TARGET_FCB|DEBUG_TARGET_REFCOUNT),
("XifsdSetRenameInformation, PFcb (%I64d) Vcb %d/%d Fcb %d/%d\n",
pParentFCB->LotNumber,
pVCB->VCBReference,
pVCB->VCBUserReference,
pParentFCB->FCBReference,
pParentFCB->FCBUserReference ));
XifsdUnlockVcb( pIrpContext, pVCB );
if(!NT_SUCCESS(RC)){
DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL,
("Fail DeleteParentChild (%wZ)\n", &pLCB->FileName));
XifsdClearFlag(pFCB->FCBFlags, XIFSD_FCB_DELETE_ON_CLOSE);
RC = STATUS_SUCCESS;
goto pass_through;
}
}else {
RC = XixFsReLoadFileFromFcb(pFCB);
if(!NT_SUCCESS(RC)){
DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL,
("Fail XixFsReLoadFileFromFcb (%wZ)\n", &pFCB->FCBName));
XifsdClearFlag(pFCB->FCBFlags, XIFSD_FCB_DELETE_ON_CLOSE);
RC = STATUS_SUCCESS;
goto pass_through;
}
if(pFCB->ChildCount != 0){
XifsdClearFlag(pFCB->FCBFlags, XIFSD_FCB_DELETE_ON_CLOSE);
RC = STATUS_SUCCESS;
goto pass_through;
}
XifsdReleaseFcb(TRUE, pFCB);
XifsdAcquireFcbExclusive(TRUE, pParentFCB, FALSE);
ParentFCBAcquired = TRUE;
XifsdAcquireFcbExclusive(TRUE, pFCB, FALSE);
RC = DeleteParentChild(pIrpContext, pParentFCB, &pLCB->FileName);
if(!NT_SUCCESS(RC)){
DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL,
("Fail DeleteParentChild (%wZ)\n", &pLCB->FileName));
//ifsdClearFlag(pFCB->FCBFlags, XIFSD_FCB_DELETE_ON_CLOSE);
RC = STATUS_SUCCESS;
goto pass_through;
}
XifsdClearFlag(pLCB->LCBFlags, XIFSD_LCB_STATE_DELETE_ON_CLOSE);
XifsdSetFlag(pLCB->LCBFlags, XIFSD_LCB_STATE_LINK_IS_GONE);
XixFsdRemovePrefix(TRUE, pLCB);
//
// Now Decrement the reference counts for the parent and drop the Vcb.
//
XifsdLockVcb(pIrpContext,pVCB);
DebugTrace( DEBUG_LEVEL_INFO, (DEBUG_TARGET_FILEINFO|DEBUG_TARGET_FCB|DEBUG_TARGET_REFCOUNT),
("XifsdSetRenameInformation, PFcb (%I64d) Vcb %d/%d Fcb %d/%d\n",
pParentFCB->LotNumber,
pVCB->VCBReference,
pVCB->VCBUserReference,
pParentFCB->FCBReference,
pParentFCB->FCBUserReference ));
XifsdDecRefCount( pParentFCB, 1, 1 );
DebugTrace( DEBUG_LEVEL_CRITICAL, (DEBUG_TARGET_FILEINFO|DEBUG_TARGET_FCB|DEBUG_TARGET_REFCOUNT),
("XifsdSetRenameInformation, PFcb (%I64d) Vcb %d/%d Fcb %d/%d\n",
pParentFCB->LotNumber,
pVCB->VCBReference,
pVCB->VCBUserReference,
pParentFCB->FCBReference,
pParentFCB->FCBUserReference ));
XifsdUnlockVcb( pIrpContext, pVCB );
if(!NT_SUCCESS(RC)){
DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL,
("Fail DeleteParentChild (%wZ)\n", &pLCB->FileName));
XifsdClearFlag(pFCB->FCBFlags, XIFSD_FCB_DELETE_ON_CLOSE);
RC = STATUS_SUCCESS;
goto pass_through;
}
}
//XixFsdDeleteUpdateFCB(pFCB);
XixFsdSendRenameLinkBC(
TRUE,
XIFS_SUBTYPE_FILE_DEL,
pVCB->HostMac,
pFCB->LotNumber,
pVCB->DiskId,
pVCB->PartitionId,
pFCB->ParentLotNumber,
0
);
}
}
}
pass_through:
XifsdLockVcb(pIrpContext, pVCB);
if(XifsdCheckFlagBoolean(pFileObject->Flags, FO_NO_INTERMEDIATE_BUFFERING))
{
ASSERT(pFCB->FcbNonCachedOpenCount > 0);
pFCB->FcbNonCachedOpenCount --;
}
XifsdDecrementClenupCount(pFCB);
DebugTrace(DEBUG_LEVEL_ALL, DEBUG_TARGET_ALL,
("Cleanup Name(%wZ) FCBLotNumber(%I64d) FCBCleanUp(%ld) VCBCleanup(%ld) pCCB(%p) FileObject(%p)\n",
&pFCB->FCBName,
pFCB->LotNumber,
pFCB->FCBCleanup,
pVCB->VCBCleanup,
pCCB,
pFileObject
));
XifsdUnlockVcb( pIrpContext, pVCB );
AttemptTeardown = (pVCB->VCBCleanup == 0 && pVCB->VCBState == XIFSD_VCB_STATE_VOLUME_DISMOUNTED );
if(pFileObject == pVCB->LockVolumeFileObject){
ASSERT(XifsdCheckFlagBoolean(pVCB->VCBFlags, XIFSD_VCB_FLAGS_VOLUME_LOCKED));
IoAcquireVpbSpinLock(&SavedIrql);
XifsdClearFlag(pVCB->PtrVPB->Flags, VPB_LOCKED);
IoReleaseVpbSpinLock( SavedIrql );
XifsdClearFlag(pVCB->VCBFlags, XIFSD_VCB_FLAGS_VOLUME_LOCKED);
pVCB->LockVolumeFileObject = NULL;
SendUnlockNotification = TRUE;
}
/*
if( (pFCB->FCBCleanup == 0)
&& (!XifsdCheckFlagBoolean(pFCB->FCBFlags, XIFSD_FCB_DELETE_ON_CLOSE)) ){
DebugTrace(DEBUG_LEVEL_INFO, (DEBUG_TARGET_CLEANUP|DEBUG_TARGET_IRPCONTEXT| DEBUG_TARGET_ALL),
("CleanUp Release Lot Lock LotNumber(%ld)\n", pFCB->LotNumber));
XifsdLotUnLock(pVCB, pVCB->TargetDeviceObject, pFCB->LotNumber);
pFCB->HasLock = FCB_FILE_LOCK_INVALID;
}
*/
//
// 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.
//
}finally{
XifsdReleaseFcb(pIrpContext, pFCB);
if(ParentFCBAcquired) {
XifsdReleaseFcb(TRUE,pParentFCB);
}
if (SendUnlockNotification) {
FsRtlNotifyVolumeEvent( pFileObject, FSRTL_VOLUME_UNLOCK );
}
if (VCBAcquired) {
XifsdReleaseVcb( pIrpContext, pVCB);
}
}
if (AttemptTeardown) {
XifsdAcquireVcbExclusive( CanWait, pVCB, FALSE );
try {
XixFsdPurgeVolume( pIrpContext, pVCB, FALSE );
} finally {
XifsdReleaseVcb( pIrpContext, pVCB );
}
}
//
// If this is a normal termination then complete the request
//
DebugTrace((DEBUG_LEVEL_TRACE), (DEBUG_TARGET_CLEANUP|DEBUG_TARGET_IRPCONTEXT),
("Exit XifsdCommonCleanUp pIrpContext(%p)\n", pIrpContext));
XixFsdCompleteRequest( pIrpContext, STATUS_SUCCESS, 0 );
return STATUS_SUCCESS;
}
/*
Routine Description:
This routine is called when all of the user references to a volume are
gone. We will initiate all of the teardown any system resources.
If all of the references to this volume are gone at the end of this routine
then we will complete the teardown of this Vcb and mark the current Vpb
as not mounted. Otherwise we will allocated a new Vpb for this device
and keep the current Vpb attached to the Vcb.
Arguments:
Vcb - Vcb for the volume to dismount.
Return Value:
BOOLEAN - TRUE if we didn't delete the Vcb, FALSE otherwise.
*/
BOOLEAN
UDFDismountVcb(
IN PVCB Vcb,
IN BOOLEAN VcbAcquired
)
{
PVPB OldVpb;
PVPB NewVpb;
BOOLEAN VcbPresent = TRUE;
KIRQL SavedIrql;
BOOLEAN FinalReference;
KdPrint(("UDFDismountVcb:\n"));
// We should only take this path once.
ASSERT( !(Vcb->VCBFlags & UDF_VCB_FLAGS_BEING_DISMOUNTED) );
// Mark the Vcb as DismountInProgress.
Vcb->VCBFlags |= UDF_VCB_FLAGS_BEING_DISMOUNTED;
// Allocate a new Vpb in case we will need it.
NewVpb = (PVPB)DbgAllocatePoolWithTag( NonPagedPool, sizeof( VPB ), 'bpvU' );
if(!NewVpb) {
Vcb->VCBFlags &= ~UDF_VCB_FLAGS_BEING_DISMOUNTED;
return TRUE;
}
RtlZeroMemory( NewVpb, sizeof(VPB) );
OldVpb = Vcb->Vpb;
// Remove the mount volume reference.
UDFCloseResidual(Vcb);
// the only residual reference is cleaned above
// Acquire the Vpb spinlock to check for Vpb references.
IoAcquireVpbSpinLock(&SavedIrql);
// Remember if this is the last reference on this Vcb. We incremented
// the count on the Vpb earlier so we get one last crack it. If our
// reference has gone to zero but the vpb reference count is greater
// than zero then the Io system will be responsible for deleting the
// Vpb.
FinalReference = (BOOLEAN)(OldVpb->ReferenceCount == 1);
// There is a reference count in the Vpb and in the Vcb. We have
// incremented the reference count in the Vpb to make sure that
// we have last crack at it. If this is a failed mount then we
// want to return the Vpb to the IO system to use for the next
// mount request.
if (OldVpb->RealDevice->Vpb == OldVpb) {
// If not the final reference then swap out the Vpb.
if (!FinalReference) {
NewVpb->Type = IO_TYPE_VPB;
NewVpb->Size = sizeof( VPB );
NewVpb->RealDevice = OldVpb->RealDevice;
NewVpb->RealDevice->Vpb = NewVpb;
NewVpb = NULL;
IoReleaseVpbSpinLock(SavedIrql);
// We want to leave the Vpb for the IO system. Mark it
// as being not mounted. Go ahead and delete the Vcb as
// well.
} else {
// Make sure to remove the last reference on the Vpb.
OldVpb->ReferenceCount--;
OldVpb->DeviceObject = NULL;
Vcb->Vpb->Flags &= ~VPB_MOUNTED;
// Clear the Vpb flag so we know not to delete it.
Vcb->Vpb = NULL;
IoReleaseVpbSpinLock(SavedIrql);
if(VcbAcquired)
UDFReleaseResource(&(Vcb->VCBResource));
UDFStopEjectWaiter(Vcb);
UDFReleaseVCB(Vcb);
VcbPresent = FALSE;
}
// Someone has already swapped in a new Vpb. If this is the final reference
// then the file system is responsible for deleting the Vpb.
} else if (FinalReference) {
// Make sure to remove the last reference on the Vpb.
OldVpb->ReferenceCount--;
IoReleaseVpbSpinLock( SavedIrql );
if(VcbAcquired)
UDFReleaseResource(&(Vcb->VCBResource));
UDFStopEjectWaiter(Vcb);
UDFReleaseVCB(Vcb);
VcbPresent = FALSE;
// The current Vpb is no longer the Vpb for the device (the IO system
// has already allocated a new one). We leave our reference in the
// Vpb and will be responsible for deleting it at a later time.
} else {
OldVpb->DeviceObject = NULL;
Vcb->Vpb->Flags &= ~VPB_MOUNTED;
IoReleaseVpbSpinLock( SavedIrql );
}
// Deallocate the new Vpb if we don't need it.
if (NewVpb != NULL) {
DbgFreePool( NewVpb );
}
// Let our caller know whether the Vcb is still present.
return VcbPresent;
} // end UDFDismountVcb()
/*
Routine Description:
This routine is called to check if a volume is ready for dismount. This
occurs when only file system references are left on the volume.
If the dismount is not currently underway and the user reference count
has gone to zero then we can begin the dismount.
If the dismount is in progress and there are no references left on the
volume (we check the Vpb for outstanding references as well to catch
any create calls dispatched to the file system) then we can delete
the Vcb.
Arguments:
Vcb - Vcb for the volume to try to dismount.
*/
BOOLEAN
UDFCheckForDismount(
IN PtrUDFIrpContext IrpContext,
IN PVCB Vcb,
IN BOOLEAN _VcbAcquired
)
{
BOOLEAN VcbPresent = TRUE;
KIRQL SavedIrql;
BOOLEAN VcbAcquired;
ULONG ResidualReferenceCount;
KdPrint(("UDFCheckForDismount:\n"));
if(!Vcb) return FALSE;
// GlobalDataResource is already acquired
if(!_VcbAcquired) {
VcbAcquired = UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE/*FALSE*/ );
if(!VcbAcquired)
return TRUE;
} else {
VcbAcquired = TRUE;
}
if ((IrpContext->MajorFunction == IRP_MJ_CREATE) &&
(IrpContext->TargetDeviceObject == Vcb->TargetDeviceObject)) {
ResidualReferenceCount = 2;
} else {
ResidualReferenceCount = 1;
}
// If the dismount is not already underway then check if the
// user reference count has gone to zero. If so start the teardown
// on the Vcb.
if (!(Vcb->VCBFlags & UDF_VCB_FLAGS_BEING_DISMOUNTED)) {
if (Vcb->VCBOpenCount <= UDF_RESIDUAL_REFERENCE) {
VcbPresent = UDFDismountVcb(Vcb, VcbAcquired);
}
VcbAcquired = VcbAcquired && VcbPresent;
// If the teardown is underway and there are absolutely no references
// remaining then delete the Vcb. References here include the
// references in the Vcb and Vpb.
} else if (!(Vcb->VCBOpenCount)) {
IoAcquireVpbSpinLock( &SavedIrql );
// If there are no file objects and no reference counts in the
// Vpb we can delete the Vcb. Don't forget that we have the
// last reference in the Vpb.
if (Vcb->Vpb->ReferenceCount <= ResidualReferenceCount) {
IoReleaseVpbSpinLock( SavedIrql );
if(VcbAcquired)
UDFReleaseResource(&(Vcb->VCBResource));
UDFStopEjectWaiter(Vcb);
UDFReleaseVCB(Vcb);
VcbAcquired =
VcbPresent = FALSE;
} else {
IoReleaseVpbSpinLock( SavedIrql );
}
}
// Release any resources still acquired.
if (!_VcbAcquired && VcbAcquired) {
UDFReleaseResource(&(Vcb->VCBResource));
}
return VcbPresent;
} // end UDFCheckForDismount()
/*
* @implemented
*/
PVPB
NTAPI
IopCheckVpbMounted(IN POPEN_PACKET OpenPacket,
IN PDEVICE_OBJECT DeviceObject,
IN PUNICODE_STRING RemainingName,
OUT PNTSTATUS Status)
{
BOOLEAN Alertable, Raw;
KIRQL OldIrql;
PVPB Vpb = NULL;
/* Lock the VPBs */
IoAcquireVpbSpinLock(&OldIrql);
/* Set VPB mount settings */
Raw = !RemainingName->Length && !OpenPacket->RelatedFileObject;
Alertable = (OpenPacket->CreateOptions & FILE_SYNCHRONOUS_IO_ALERT) ?
TRUE: FALSE;
/* Start looping until the VPB is mounted */
while (!(DeviceObject->Vpb->Flags & VPB_MOUNTED))
{
/* Release the lock */
IoReleaseVpbSpinLock(OldIrql);
/* Mount the volume */
*Status = IopMountVolume(DeviceObject,
Raw,
FALSE,
Alertable,
&Vpb);
/* Check if we failed or if we were alerted */
if (!(NT_SUCCESS(*Status)) ||
(*Status == STATUS_USER_APC) ||
(*Status == STATUS_ALERTED))
{
/* Dereference the device, since IopParseDevice referenced it */
IopDereferenceDeviceObject(DeviceObject, FALSE);
/* Check if it was a total failure */
if (!NT_SUCCESS(*Status)) return NULL;
/* Otherwise we were alerted */
*Status = STATUS_WRONG_VOLUME;
return NULL;
}
/* Re-acquire the lock */
IoAcquireVpbSpinLock(&OldIrql);
}
/* Make sure the VPB isn't locked */
Vpb = DeviceObject->Vpb;
if (Vpb->Flags & VPB_LOCKED)
{
/* We're locked, so fail */
*Status = STATUS_ACCESS_DENIED;
Vpb = NULL;
}
else
{
/* Success! Reference the VPB */
Vpb->ReferenceCount++;
}
/* Release the lock and return the VPB */
IoReleaseVpbSpinLock(OldIrql);
return Vpb;
}
__drv_mustHoldCriticalRegion
BOOLEAN
RfsdCheckDismount (
IN PRFSD_IRP_CONTEXT IrpContext,
IN PRFSD_VCB Vcb,
IN BOOLEAN bForce )
{
KIRQL Irql;
PVPB Vpb = Vcb->Vpb;
BOOLEAN bDeleted = FALSE;
ULONG UnCleanCount = 0;
PAGED_CODE();
ExAcquireResourceExclusiveLite(
&RfsdGlobal->Resource, TRUE );
ExAcquireResourceExclusiveLite(
&Vcb->MainResource, TRUE );
if ((IrpContext->MajorFunction == IRP_MJ_CREATE) &&
(IrpContext->RealDevice == Vcb->RealDevice)) {
UnCleanCount = 3;
} else {
UnCleanCount = 2;
}
IoAcquireVpbSpinLock (&Irql);
if ((Vpb->ReferenceCount == UnCleanCount) || bForce) {
if ((Vpb->ReferenceCount != UnCleanCount) && bForce) {
KdPrint(("RfsdCheckDismount: force dismount ...\n"));
}
ClearFlag( Vpb->Flags, VPB_MOUNTED );
ClearFlag( Vpb->Flags, VPB_LOCKED );
#ifdef _MSC_VER
#pragma prefast( suppress: 28175, "allowed in file system drivers" )
#endif
if ((Vcb->RealDevice != Vpb->RealDevice) &&
(Vcb->RealDevice->Vpb == Vpb)) {
SetFlag( Vcb->RealDevice->Flags, DO_DEVICE_INITIALIZING );
SetFlag( Vpb->Flags, VPB_PERSISTENT );
}
RfsdRemoveVcb(Vcb);
ClearFlag(Vpb->Flags, VPB_MOUNTED);
SetFlag(Vcb->Flags, VCB_DISMOUNT_PENDING);
Vpb->DeviceObject = NULL;
bDeleted = TRUE;
}
IoReleaseVpbSpinLock(Irql);
ExReleaseResourceForThreadLite(
&Vcb->MainResource,
ExGetCurrentResourceThread() );
ExReleaseResourceForThreadLite(
&RfsdGlobal->Resource,
ExGetCurrentResourceThread() );
if (bDeleted) {
KdPrint(("RfsdCheckDismount: now free the vcb ...\n"));
RfsdFreeVcb(Vcb);
}
return bDeleted;
}
BOOLEAN
RawCheckForDismount (
PVCB Vcb,
BOOLEAN CalledFromCreate
)
/*++
Routine Description:
This routine determines if a volume is ready for deletion. It
correctly synchronizes with creates en-route to the file system.
On exit if the vcb is deleted the mutex is released
Arguments:
Vcb - Supplies the value to examine
CalledFromCreate - Tells us if we should allow 0 or 1 in VpbRefCount
Return Value:
BOOLEAN - TRUE if the volume was deleted, FALSE otherwise.
--*/
{
KIRQL SavedIrql;
ULONG ReferenceCount = 0;
BOOLEAN DeleteVolume = FALSE;
//
// We must enter with the vcb mutex acquired
//
ASSERT( KeReadStateMutant( &Vcb->Mutex ) == 0 );
IoAcquireVpbSpinLock( &SavedIrql );
ReferenceCount = Vcb->Vpb->ReferenceCount;
{
PVPB Vpb;
Vpb = Vcb->Vpb;
//
// If a create is in progress on this volume, don't
// delete it.
//
if ( ReferenceCount != (ULONG)(CalledFromCreate ? 1 : 0) ) {
//
// Cleanup the vpb on a forced dismount even if we can't delete the vcb if
// we haven't already done so
//
if ((Vcb->SpareVpb != NULL) &&
FlagOn( Vcb->VcbState, VCB_STATE_FLAG_DISMOUNTED )) {
//
// Setup the spare vpb and put it on the real device
//
RtlZeroMemory( Vcb->SpareVpb, sizeof( VPB ) );
Vcb->SpareVpb->Type = IO_TYPE_VPB;
Vcb->SpareVpb->Size = sizeof( VPB );
Vcb->SpareVpb->RealDevice = Vcb->Vpb->RealDevice;
Vcb->SpareVpb->DeviceObject = NULL;
Vcb->SpareVpb->Flags = FlagOn( Vcb->Vpb->Flags, VPB_REMOVE_PENDING );
Vcb->Vpb->RealDevice->Vpb = Vcb->SpareVpb;
//
// The spare vpb now belongs to the iosubsys and we own the original one
//
Vcb->SpareVpb = NULL;
Vcb->Vpb->Flags |= VPB_PERSISTENT;
}
DeleteVolume = FALSE;
} else {
DeleteVolume = TRUE;
if ( Vpb->RealDevice->Vpb == Vpb ) {
Vpb->DeviceObject = NULL;
Vpb->Flags &= ~VPB_MOUNTED;
}
}
}
IoReleaseVpbSpinLock( SavedIrql );
if (DeleteVolume) {
(VOID)KeReleaseMutex( &Vcb->Mutex, FALSE );
//
// Free the spare vpb if we didn't use it or the original one if
// we did use it and there are no more reference counts. Otherwise i/o
// subsystem still has a ref and will free the vpb itself
//
if (Vcb->SpareVpb) {
ExFreePool( Vcb->SpareVpb );
} else if (ReferenceCount == 0) {
ExFreePool( Vcb->Vpb );
}
ObDereferenceObject( Vcb->TargetDeviceObject );
IoDeleteDevice( (PDEVICE_OBJECT)CONTAINING_RECORD( Vcb,
VOLUME_DEVICE_OBJECT,
Vcb));
}
return DeleteVolume;
}
VOID
NtfsReleaseVcbCheckDelete (
IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb,
IN UCHAR MajorCode,
IN PFILE_OBJECT FileObject OPTIONAL
)
/*++
Routine Description:
This routine will release the Vcb. We will also test here whether we should
teardown the Vcb at this point. If this is the last open queued to a dismounted
volume or the last close from a failed mount or the failed mount then we will
want to test the Vcb for a teardown.
Arguments:
Vcb - Supplies the Vcb to acquire
MajorCode - Indicates what type of operation we were called from.
FileObject - Optionally supplies the file object whose VPB pointer we need to
zero out
Return Value:
None.
--*/
{
ASSERT_IRP_CONTEXT(IrpContext);
ASSERT_VCB(Vcb);
if (FlagOn( Vcb->VcbState, VCB_STATE_PERFORMED_DISMOUNT ) &&
(Vcb->CloseCount == 0)) {
ULONG ReferenceCount;
ULONG ResidualCount;
KIRQL SavedIrql;
BOOLEAN DeleteVcb = FALSE;
ASSERT_EXCLUSIVE_RESOURCE( &Vcb->Resource );
//
// The volume has gone through dismount. Now we need to decide if this
// release of the Vcb is the last reference for this volume. If so we
// can tear the volume down.
//
// We compare the reference count in the Vpb with the state of the volume
// and the type of operation. We also need to check if there is a
// referenced log file object.
//
IoAcquireVpbSpinLock( &SavedIrql );
ReferenceCount = Vcb->Vpb->ReferenceCount;
IoReleaseVpbSpinLock( SavedIrql );
ResidualCount = 0;
if (Vcb->LogFileObject != NULL) {
ResidualCount = 1;
}
if (MajorCode == IRP_MJ_CREATE) {
ResidualCount += 1;
}
//
// If the residual count is the same as the count in the Vpb then we
// can delete the Vpb.
//
if (ResidualCount == ReferenceCount) {
SetFlag( Vcb->VcbState, VCB_STATE_DELETE_UNDERWAY );
ExReleaseResource( &Vcb->Resource );
//
// Never delete the Vcb unless this is the last release of
// this Vcb.
//
if (!ExIsResourceAcquiredExclusive( &Vcb->Resource ) &&
(ExIsResourceAcquiredShared( &Vcb->Resource ) == 0)) {
if (ARGUMENT_PRESENT(FileObject)) { FileObject->Vpb = NULL; }
//
// If this is a create then the IO system will handle the
// Vpb.
//
if (MajorCode == IRP_MJ_CREATE) {
ClearFlag( Vcb->VcbState, VCB_STATE_TEMP_VPB );
}
//
// Use the global resource to synchronize the DeleteVcb process.
//
(VOID) ExAcquireResourceExclusive( &NtfsData.Resource, TRUE );
RemoveEntryList( &Vcb->VcbLinks );
ExReleaseResource( &NtfsData.Resource );
NtfsDeleteVcb( IrpContext, &Vcb );
} else {
ClearFlag( Vcb->VcbState, VCB_STATE_DELETE_UNDERWAY );
}
} else {
ExReleaseResource( &Vcb->Resource );
}
} else {
ExReleaseResource( &Vcb->Resource );
}
}
BOOLEAN
CdDismountVcb (
IN PIRP_CONTEXT IrpContext,
IN PVCB Vcb
)
/*++
Routine Description:
This routine is called when all of the user references to a volume are
gone. We will initiate all of the teardown any system resources.
If all of the references to this volume are gone at the end of this routine
then we will complete the teardown of this Vcb and mark the current Vpb
as not mounted. Otherwise we will allocated a new Vpb for this device
and keep the current Vpb attached to the Vcb.
Arguments:
Vcb - Vcb for the volume to dismount.
Return Value:
BOOLEAN - TRUE if we didn't delete the Vcb, FALSE otherwise.
--*/
{
PVPB OldVpb;
BOOLEAN VcbPresent = TRUE;
KIRQL SavedIrql;
BOOLEAN FinalReference;
ASSERT_EXCLUSIVE_CDDATA;
ASSERT_EXCLUSIVE_VCB( Vcb );
CdLockVcb( IrpContext, Vcb );
//
// We should only take this path once.
//
ASSERT( Vcb->VcbCondition != VcbDismountInProgress );
//
// Mark the Vcb as DismountInProgress.
//
Vcb->VcbCondition = VcbDismountInProgress;
if (Vcb->XASector != NULL) {
CdFreePool( &Vcb->XASector );
Vcb->XASector = 0;
Vcb->XADiskOffset = 0;
}
//
// Remove our reference to the internal Fcb's. The Fcb's will then
// be removed in the purge path below.
//
if (Vcb->RootIndexFcb != NULL) {
Vcb->RootIndexFcb->FcbReference -= 1;
Vcb->RootIndexFcb->FcbUserReference -= 1;
}
if (Vcb->PathTableFcb != NULL) {
Vcb->PathTableFcb->FcbReference -= 1;
Vcb->PathTableFcb->FcbUserReference -= 1;
}
if (Vcb->VolumeDasdFcb != NULL) {
Vcb->VolumeDasdFcb->FcbReference -= 1;
Vcb->VolumeDasdFcb->FcbUserReference -= 1;
}
CdUnlockVcb( IrpContext, Vcb );
//
// Purge the volume.
//
CdPurgeVolume( IrpContext, Vcb, TRUE );
//
// Empty the delayed and async close queues.
//
CdFspClose( Vcb );
OldVpb = Vcb->Vpb;
//
// Remove the mount volume reference.
//
CdLockVcb( IrpContext, Vcb );
Vcb->VcbReference -= 1;
//
// Acquire the Vpb spinlock to check for Vpb references.
//
IoAcquireVpbSpinLock( &SavedIrql );
//
// Remember if this is the last reference on this Vcb. We incremented
// the count on the Vpb earlier so we get one last crack it. If our
// reference has gone to zero but the vpb reference count is greater
// than zero then the Io system will be responsible for deleting the
// Vpb.
//
FinalReference = (BOOLEAN) ((Vcb->VcbReference == 0) &&
(OldVpb->ReferenceCount == 1));
//
// There is a reference count in the Vpb and in the Vcb. We have
// incremented the reference count in the Vpb to make sure that
// we have last crack at it. If this is a failed mount then we
// want to return the Vpb to the IO system to use for the next
// mount request.
//
if (OldVpb->RealDevice->Vpb == OldVpb) {
//
// If not the final reference then swap out the Vpb. We must
// preserve the REMOVE_PENDING flag so that the device is
// not remounted in the middle of a PnP remove operation.
//
if (!FinalReference) {
ASSERT( Vcb->SwapVpb != NULL );
Vcb->SwapVpb->Type = IO_TYPE_VPB;
Vcb->SwapVpb->Size = sizeof( VPB );
Vcb->SwapVpb->RealDevice = OldVpb->RealDevice;
Vcb->SwapVpb->RealDevice->Vpb = Vcb->SwapVpb;
Vcb->SwapVpb->Flags = FlagOn( OldVpb->Flags, VPB_REMOVE_PENDING );
IoReleaseVpbSpinLock( SavedIrql );
//
// Indicate we used up the swap.
//
Vcb->SwapVpb = NULL;
CdUnlockVcb( IrpContext, Vcb );
//
// We want to leave the Vpb for the IO system. Mark it
// as being not mounted. Go ahead and delete the Vcb as
// well.
//
} else {
//
// Make sure to remove the last reference on the Vpb.
//
OldVpb->ReferenceCount -= 1;
OldVpb->DeviceObject = NULL;
ClearFlag( Vcb->Vpb->Flags, VPB_MOUNTED );
ClearFlag( Vcb->Vpb->Flags, VPB_LOCKED );
//
// Clear the Vpb flag so we know not to delete it.
//
Vcb->Vpb = NULL;
IoReleaseVpbSpinLock( SavedIrql );
CdUnlockVcb( IrpContext, Vcb );
CdDeleteVcb( IrpContext, Vcb );
VcbPresent = FALSE;
}
//
// Someone has already swapped in a new Vpb. If this is the final reference
// then the file system is responsible for deleting the Vpb.
//
} else if (FinalReference) {
//
// Make sure to remove the last reference on the Vpb.
//
OldVpb->ReferenceCount -= 1;
IoReleaseVpbSpinLock( SavedIrql );
CdUnlockVcb( IrpContext, Vcb );
CdDeleteVcb( IrpContext, Vcb );
VcbPresent = FALSE;
//
// The current Vpb is no longer the Vpb for the device (the IO system
// has already allocated a new one). We leave our reference in the
// Vpb and will be responsible for deleting it at a later time.
//
} else {
IoReleaseVpbSpinLock( SavedIrql );
CdUnlockVcb( IrpContext, Vcb );
}
//
// Let our caller know whether the Vcb is still present.
//
return VcbPresent;
}
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;
}
__drv_mustHoldCriticalRegion
BOOLEAN
FFSCheckDismount(
IN PFFS_IRP_CONTEXT IrpContext,
IN PFFS_VCB Vcb,
IN BOOLEAN bForce)
{
KIRQL Irql;
PVPB Vpb = Vcb->Vpb;
BOOLEAN bDeleted = FALSE;
ULONG UnCleanCount = 0;
PAGED_CODE();
ExAcquireResourceExclusiveLite(
&FFSGlobal->Resource, TRUE);
ExAcquireResourceExclusiveLite(
&Vcb->MainResource, TRUE);
if ((IrpContext->MajorFunction == IRP_MJ_CREATE) &&
(IrpContext->RealDevice == Vcb->RealDevice))
{
UnCleanCount = 3;
}
else
{
UnCleanCount = 2;
}
IoAcquireVpbSpinLock(&Irql);
if ((Vpb->ReferenceCount == UnCleanCount) || bForce)
{
if ((Vpb->ReferenceCount != UnCleanCount) && bForce)
{
FFSBreakPoint();
}
ClearFlag(Vpb->Flags, VPB_MOUNTED);
ClearFlag(Vpb->Flags, VPB_LOCKED);
if ((Vcb->RealDevice != Vpb->RealDevice) &&
#ifdef _MSC_VER
#pragma prefast( suppress: 28175, "allowed in file system drivers" )
#endif
(Vcb->RealDevice->Vpb == Vpb))
{
SetFlag(Vcb->RealDevice->Flags, DO_DEVICE_INITIALIZING);
SetFlag(Vpb->Flags, VPB_PERSISTENT);
}
FFSRemoveVcb(Vcb);
ClearFlag(Vpb->Flags, VPB_MOUNTED);
SetFlag(Vcb->Flags, VCB_DISMOUNT_PENDING);
Vpb->DeviceObject = NULL;
bDeleted = TRUE;
}
#if 0
else if ((Vpb->RealDevice->Vpb == Vpb) && bForce)
{
PVPB NewVpb;
#define TAG_VPB ' bpV'
NewVpb = ExAllocatePoolWithTag(NonPagedPoolMustSucceed,
sizeof(VPB), TAG_VPB);
NewVpb->Type = IO_TYPE_VPB;
NewVpb->Size = sizeof(VPB);
NewVpb->RealDevice = Vcb->Vpb->RealDevice;
NewVpb->RealDevice->Vpb = NewVpb;
NewVpb->Flags = FlagOn(Vcb->Vpb->Flags, VPB_REMOVE_PENDING);
NewVpb = NULL;
ClearFlag(Vcb->Flags, VCB_MOUNTED);
ClearFlag(Vcb->Flags, VCB_DISMOUNT_PENDING);
}
#endif
IoReleaseVpbSpinLock(Irql);
ExReleaseResourceForThreadLite(
&Vcb->MainResource,
ExGetCurrentResourceThread());
ExReleaseResourceForThreadLite(
&FFSGlobal->Resource,
ExGetCurrentResourceThread());
if (bDeleted)
{
#if 0
FFSBreakPoint(); /* XP에서 브레이크 포인트 발생 */
#endif
FFSFreeVcb(Vcb);
}
return bDeleted;
}
