////////////////////////////////////////////////////////////////////
// Copyright (C) Alexander Telyatnikov, Ivan Keliukh, Yegor Anchishkin, SKIF Software, 1999-2013. Kiev, Ukraine
// All rights reserved
// This file was released under the GPLv2 on June 2015.
////////////////////////////////////////////////////////////////////
/*************************************************************************
*
* File: Flush.cpp
*
* Module: UDF File System Driver (Kernel mode execution only)
*
* Description:
* Contains code to handle the "Flush Buffers" dispatch entry point.
*
*************************************************************************/
#include "udffs.h"
// define the file specific bug-check id
#define UDF_BUG_CHECK_ID UDF_FILE_FLUSH
/*************************************************************************
*
* Function: UDFFlush()
*
* Description:
* The I/O Manager will invoke this routine to handle a flush buffers
* request
*
* Expected Interrupt Level (for execution) :
*
* IRQL_PASSIVE_LEVEL (invocation at higher IRQL will cause execution
* to be deferred to a worker thread context)
*
* Return Value: STATUS_SUCCESS/Error
*
*************************************************************************/
NTSTATUS
NTAPI
UDFFlush(
PDEVICE_OBJECT DeviceObject, // the logical volume device object
PIRP Irp) // I/O Request Packet
{
NTSTATUS RC = STATUS_SUCCESS;
PtrUDFIrpContext PtrIrpContext = NULL;
BOOLEAN AreWeTopLevel = FALSE;
UDFPrint(("UDFFlush: \n"));
FsRtlEnterFileSystem();
ASSERT(DeviceObject);
ASSERT(Irp);
// set the top level context
AreWeTopLevel = UDFIsIrpTopLevel(Irp);
ASSERT(!UDFIsFSDevObj(DeviceObject));
_SEH2_TRY {
// get an IRP context structure and issue the request
PtrIrpContext = UDFAllocateIrpContext(Irp, DeviceObject);
if(PtrIrpContext) {
RC = UDFCommonFlush(PtrIrpContext, Irp);
} else {
RC = STATUS_INSUFFICIENT_RESOURCES;
Irp->IoStatus.Status = RC;
Irp->IoStatus.Information = 0;
// complete the IRP
IoCompleteRequest(Irp, IO_DISK_INCREMENT);
}
} _SEH2_EXCEPT(UDFExceptionFilter(PtrIrpContext, _SEH2_GetExceptionInformation())) {
RC = UDFExceptionHandler(PtrIrpContext, Irp);
UDFLogEvent(UDF_ERROR_INTERNAL_ERROR, RC);
} _SEH2_END;
if (AreWeTopLevel) {
IoSetTopLevelIrp(NULL);
}
FsRtlExitFileSystem();
return(RC);
} // end UDFFlush()
/*************************************************************************
*
* Function: UDFCommonFlush()
*
* Description:
* The actual work is performed here. This routine may be invoked in one'
* of the two possible contexts:
* (a) in the context of a system worker thread
* (b) in the context of the original caller
*
* Expected Interrupt Level (for execution) :
*
* IRQL_PASSIVE_LEVEL
*
* Return Value: STATUS_SUCCESS/Error
*
*************************************************************************/
NTSTATUS
UDFCommonFlush(
PtrUDFIrpContext PtrIrpContext,
PIRP Irp
)
{
NTSTATUS RC = STATUS_SUCCESS;
PIO_STACK_LOCATION IrpSp = NULL;
PFILE_OBJECT FileObject = NULL;
PtrUDFFCB Fcb = NULL;
PtrUDFCCB Ccb = NULL;
PVCB Vcb = NULL;
PtrUDFNTRequiredFCB NtReqFcb = NULL;
BOOLEAN AcquiredVCB = FALSE;
BOOLEAN AcquiredFCB = FALSE;
BOOLEAN PostRequest = FALSE;
BOOLEAN CanWait = TRUE;
UDFPrint(("UDFCommonFlush: \n"));
_SEH2_TRY {
// Get some of the parameters supplied to us
CanWait = ((PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_CAN_BLOCK) ? TRUE : FALSE);
// If we cannot wait, post the request immediately since a flush is inherently blocking/synchronous.
if (!CanWait) {
PostRequest = TRUE;
try_return(RC);
}
// First, get a pointer to the current I/O stack location
IrpSp = IoGetCurrentIrpStackLocation(Irp);
ASSERT(IrpSp);
FileObject = IrpSp->FileObject;
ASSERT(FileObject);
// Get the FCB and CCB pointers
Ccb = (PtrUDFCCB)(FileObject->FsContext2);
ASSERT(Ccb);
Fcb = Ccb->Fcb;
ASSERT(Fcb);
NtReqFcb = Fcb->NTRequiredFCB;
// Check the type of object passed-in. That will determine the course of
// action we take.
if ((Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB) || (Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY)) {
if (Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB) {
Vcb = (PVCB)(Fcb);
} else {
Vcb = Fcb->Vcb;
}
Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
#ifdef UDF_DELAYED_CLOSE
UDFCloseAllDelayed(Vcb);
#endif //UDF_DELAYED_CLOSE
UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
AcquiredVCB = TRUE;
// The caller wishes to flush all files for the mounted
// logical volume. The flush volume routine below should simply
// walk through all of the open file streams, acquire the
// VCB resource, and request the flush operation from the Cache
// Manager. Basically, the sequence of operations listed below
// for a single file should be executed on all open files.
UDFFlushLogicalVolume(PtrIrpContext, Irp, Vcb, 0);
UDFReleaseResource(&(Vcb->VCBResource));
AcquiredVCB = FALSE;
try_return(RC);
} else
if (!(Fcb->FCBFlags & UDF_FCB_DIRECTORY)) {
// This is a regular file.
Vcb = Fcb->Vcb;
ASSERT(Vcb);
if(!ExIsResourceAcquiredExclusiveLite(&(Vcb->VCBResource)) &&
!ExIsResourceAcquiredSharedLite(&(Vcb->VCBResource))) {
UDFAcquireResourceShared(&(Vcb->VCBResource), TRUE);
AcquiredVCB = TRUE;
}
UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
UDFAcquireResourceExclusive(&(NtReqFcb->MainResource), TRUE);
AcquiredFCB = TRUE;
// Request the Cache Manager to perform a flush operation.
// Further, instruct the Cache Manager that we wish to flush the
// entire file stream.
UDFFlushAFile(Fcb, Ccb, &(Irp->IoStatus), 0);
RC = Irp->IoStatus.Status;
// Some log-based FSD implementations may wish to flush their
// log files at this time. Finally, we should update the time-stamp
// values for the file stream appropriately. This would involve
// obtaining the current time and modifying the appropriate directory
// entry fields.
} else {
Vcb = Fcb->Vcb;
}
try_exit: NOTHING;
} _SEH2_FINALLY {
if (AcquiredFCB) {
UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
UDFReleaseResource(&(NtReqFcb->MainResource));
AcquiredFCB = FALSE;
}
if (AcquiredVCB) {
UDFReleaseResource(&(Vcb->VCBResource));
AcquiredVCB = FALSE;
}
if(!_SEH2_AbnormalTermination()) {
if (PostRequest) {
// Nothing to lock now.
BrutePoint();
RC = UDFPostRequest(PtrIrpContext, Irp);
} else {
// Some applications like this request very much
// (ex. WinWord). But it's not a good idea for CD-R/RW media
if(Vcb->FlushMedia) {
PIO_STACK_LOCATION PtrNextIoStackLocation = NULL;
NTSTATUS RC1 = STATUS_SUCCESS;
// Send the request down at this point.
// To do this, we must set the next IRP stack location, and
// maybe set a completion routine.
// Be careful about marking the IRP pending if the lower level
// driver returned pending and we do have a completion routine!
PtrNextIoStackLocation = IoGetNextIrpStackLocation(Irp);
*PtrNextIoStackLocation = *IrpSp;
// Set the completion routine to "eat-up" any
// STATUS_INVALID_DEVICE_REQUEST error code returned by the lower
// level driver.
IoSetCompletionRoutine(Irp, UDFFlushCompletion, NULL, TRUE, TRUE, TRUE);
RC1 = IoCallDriver(Vcb->TargetDeviceObject, Irp);
RC = ((RC1 == STATUS_INVALID_DEVICE_REQUEST) ? RC : RC1);
// Release the IRP context at this time.
UDFReleaseIrpContext(PtrIrpContext);
} else {
Irp->IoStatus.Status = RC;
Irp->IoStatus.Information = 0;
// Free up the Irp Context
UDFReleaseIrpContext(PtrIrpContext);
// complete the IRP
IoCompleteRequest(Irp, IO_DISK_INCREMENT);
}
}
}
} _SEH2_END;
return(RC);
} // end UDFCommonFlush()
/*************************************************************************
*
* Function: UDFFlushAFile()
*
* Description:
* Tell the Cache Manager to perform a flush.
*
* Expected Interrupt Level (for execution) :
*
* IRQL_PASSIVE_LEVEL
*
* Return Value: None
*
*************************************************************************/
ULONG
UDFFlushAFile(
IN PtrUDFFCB Fcb,
IN PtrUDFCCB Ccb,
OUT PIO_STATUS_BLOCK PtrIoStatus,
IN ULONG FlushFlags
)
{
BOOLEAN SetArchive = FALSE;
// BOOLEAN PurgeCache = FALSE;
ULONG ret_val = 0;
UDFPrint(("UDFFlushAFile: \n"));
if(!Fcb)
return 0;
_SEH2_TRY {
if(Fcb->Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK)
return 0;
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
BrutePoint();
} _SEH2_END;
#ifndef UDF_READ_ONLY_BUILD
// Flush Security if required
_SEH2_TRY {
UDFWriteSecurity(Fcb->Vcb, Fcb, &(Fcb->NTRequiredFCB->SecurityDesc));
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
BrutePoint();
} _SEH2_END;
#endif //UDF_READ_ONLY_BUILD
// Flush SDir if any
_SEH2_TRY {
if(UDFHasAStreamDir(Fcb->FileInfo) &&
Fcb->FileInfo->Dloc->SDirInfo &&
!UDFIsSDirDeleted(Fcb->FileInfo->Dloc->SDirInfo) ) {
ret_val |=
UDFFlushADirectory(Fcb->Vcb, Fcb->FileInfo->Dloc->SDirInfo, PtrIoStatus, FlushFlags);
}
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
BrutePoint();
} _SEH2_END;
// Flush File
_SEH2_TRY {
if((Fcb->CachedOpenHandleCount || !Fcb->OpenHandleCount) &&
Fcb->NTRequiredFCB->SectionObject.DataSectionObject) {
if(!(Fcb->NTRequiredFCB->NtReqFCBFlags & UDF_NTREQ_FCB_DELETED)
&&
((Fcb->NTRequiredFCB->NtReqFCBFlags & UDF_NTREQ_FCB_MODIFIED) ||
(Ccb && !(Ccb->CCBFlags & UDF_CCB_FLUSHED)) )) {
MmPrint((" CcFlushCache()\n"));
CcFlushCache(&(Fcb->NTRequiredFCB->SectionObject), NULL, 0, PtrIoStatus);
}
// notice, that we should purge cache
// we can't do it now, because it may cause last Close
// request & thus, structure deallocation
// PurgeCache = TRUE;
#ifndef UDF_READ_ONLY_BUILD
if(Ccb) {
if( (Ccb->FileObject->Flags & FO_FILE_MODIFIED) &&
!(Ccb->CCBFlags & UDF_CCB_WRITE_TIME_SET)) {
if(Fcb->Vcb->CompatFlags & UDF_VCB_IC_UPDATE_MODIFY_TIME) {
LONGLONG NtTime;
KeQuerySystemTime((PLARGE_INTEGER)&NtTime);
UDFSetFileXTime(Fcb->FileInfo, NULL, NULL, NULL, &NtTime);
Fcb->NTRequiredFCB->LastWriteTime.QuadPart = NtTime;
}
SetArchive = TRUE;
Ccb->FileObject->Flags &= ~FO_FILE_MODIFIED;
}
if(Ccb->FileObject->Flags & FO_FILE_SIZE_CHANGED) {
LONGLONG ASize = UDFGetFileAllocationSize(Fcb->Vcb, Fcb->FileInfo);
UDFSetFileSizeInDirNdx(Fcb->Vcb, Fcb->FileInfo, &ASize);
Ccb->FileObject->Flags &= ~FO_FILE_SIZE_CHANGED;
}
}
#endif //UDF_READ_ONLY_BUILD
}
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
BrutePoint();
} _SEH2_END;
_SEH2_TRY {
#ifndef UDF_READ_ONLY_BUILD
if(SetArchive &&
(Fcb->Vcb->CompatFlags & UDF_VCB_IC_UPDATE_ARCH_BIT)) {
ULONG Attr;
PDIR_INDEX_ITEM DirNdx;
DirNdx = UDFDirIndex(UDFGetDirIndexByFileInfo(Fcb->FileInfo), Fcb->FileInfo->Index);
// Archive bit
Attr = UDFAttributesToNT(DirNdx, Fcb->FileInfo->Dloc->FileEntry);
if(!(Attr & FILE_ATTRIBUTE_ARCHIVE))
UDFAttributesToUDF(DirNdx, Fcb->FileInfo->Dloc->FileEntry, Attr | FILE_ATTRIBUTE_ARCHIVE);
}
#endif //UDF_READ_ONLY_BUILD
UDFFlushFile__( Fcb->Vcb, Fcb->FileInfo, FlushFlags);
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
BrutePoint();
} _SEH2_END;
/* if(PurgeCache) {
_SEH2_TRY {
MmPrint((" CcPurgeCacheSection()\n"));
CcPurgeCacheSection( &(Fcb->NTRequiredFCB->SectionObject), NULL, 0, FALSE );
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
BrutePoint();
} _SEH2_END;
}*/
return ret_val;
} // end UDFFlushAFile()
/*************************************************************************
*
* Function: UDFFlushADirectory()
*
* Description:
* Tell the Cache Manager to perform a flush for all files
* in current directory & all subdirectories and flush all metadata
*
* Expected Interrupt Level (for execution) :
*
* IRQL_PASSIVE_LEVEL
*
* Return Value: None
*
*************************************************************************/
ULONG
UDFFlushADirectory(
IN PVCB Vcb,
IN PUDF_FILE_INFO FI,
OUT PIO_STATUS_BLOCK PtrIoStatus,
IN ULONG FlushFlags
)
{
UDFPrint(("UDFFlushADirectory: \n"));
// PDIR_INDEX_HDR hDI;
PDIR_INDEX_ITEM DI;
// BOOLEAN Referenced = FALSE;
ULONG ret_val = 0;
if(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK)
return 0;
if(!FI || !FI->Dloc || !FI->Dloc->DirIndex) goto SkipFlushDir;
// hDI = FI->Dloc->DirIndex;
// Flush Security if required
_SEH2_TRY {
UDFWriteSecurity(Vcb, FI->Fcb, &(FI->Fcb->NTRequiredFCB->SecurityDesc));
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
BrutePoint();
} _SEH2_END;
// Flush SDir if any
_SEH2_TRY {
if(UDFHasAStreamDir(FI) &&
FI->Dloc->SDirInfo &&
!UDFIsSDirDeleted(FI->Dloc->SDirInfo) ) {
ret_val |=
UDFFlushADirectory(Vcb, FI->Dloc->SDirInfo, PtrIoStatus, FlushFlags);
}
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
BrutePoint();
} _SEH2_END;
// Flush Dir Tree
_SEH2_TRY {
UDF_DIR_SCAN_CONTEXT ScanContext;
PUDF_FILE_INFO tempFI;
if(UDFDirIndexInitScan(FI, &ScanContext, 2)) {
while((DI = UDFDirIndexScan(&ScanContext, &tempFI))) {
// Flush Dir entry
_SEH2_TRY {
if(!tempFI) continue;
if(UDFIsADirectory(tempFI)) {
UDFFlushADirectory(Vcb, tempFI, PtrIoStatus, FlushFlags);
} else {
UDFFlushAFile(tempFI->Fcb, NULL, PtrIoStatus, FlushFlags);
}
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
BrutePoint();
} _SEH2_END;
if(UDFFlushIsBreaking(Vcb, FlushFlags)) {
ret_val |= UDF_FLUSH_FLAGS_INTERRUPTED;
break;
}
}
}
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
BrutePoint();
} _SEH2_END;
SkipFlushDir:
// Flush Dir
_SEH2_TRY {
UDFFlushFile__( Vcb, FI, FlushFlags );
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
BrutePoint();
} _SEH2_END;
return ret_val;
} // end UDFFlushADirectory()
/*************************************************************************
*
* Function: UDFFlushLogicalVolume()
*
* Description:
* Flush everything beginning from root directory.
* Vcb must be previously acquired exclusively.
*
* Expected Interrupt Level (for execution) :
*
* IRQL_PASSIVE_LEVEL
*
* Return Value: None
*
*************************************************************************/
ULONG
UDFFlushLogicalVolume(
IN PtrUDFIrpContext PtrIrpContext,
IN PIRP Irp,
IN PVCB Vcb,
IN ULONG FlushFlags
)
{
ULONG ret_val = 0;
#ifndef UDF_READ_ONLY_BUILD
IO_STATUS_BLOCK IoStatus;
UDFPrint(("UDFFlushLogicalVolume: \n"));
_SEH2_TRY {
if(Vcb->VCBFlags & (UDF_VCB_FLAGS_RAW_DISK/* |
UDF_VCB_FLAGS_MEDIA_READ_ONLY*/))
return 0;
if(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY)
return 0;
if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED))
return 0;
// NOTE: This function may also be invoked internally as part of
// processing a shutdown request.
ASSERT(Vcb->RootDirFCB);
ret_val |= UDFFlushADirectory(Vcb, Vcb->RootDirFCB->FileInfo, &IoStatus, FlushFlags);
// if(UDFFlushIsBreaking(Vcb, FlushFlags))
// return;
// flush internal cache
if(FlushFlags & UDF_FLUSH_FLAGS_LITE) {
UDFPrint((" Lite flush, keep Modified=%d.\n", Vcb->Modified));
} else {
if(Vcb->VerifyOnWrite) {
UDFPrint(("UDF: Flushing cache for verify\n"));
//WCacheFlushAll__(&(Vcb->FastCache), Vcb);
WCacheFlushBlocks__(&(Vcb->FastCache), Vcb, 0, Vcb->LastLBA);
UDFVFlush(Vcb);
}
// umount (this is internal operation, NT will "dismount" volume later)
UDFUmount__(Vcb);
UDFPreClrModified(Vcb);
WCacheFlushAll__(&(Vcb->FastCache), Vcb);
UDFClrModified(Vcb);
}
} _SEH2_FINALLY {
;
} _SEH2_END;
#endif //UDF_READ_ONLY_BUILD
return ret_val;
} // end UDFFlushLogicalVolume()
/*************************************************************************
*
* Function: UDFFlushCompletion()
*
* Description:
* Eat up any bad errors.
*
* Expected Interrupt Level (for execution) :
*
* IRQL_PASSIVE_LEVEL
*
* Return Value: None
*
*************************************************************************/
NTSTATUS
NTAPI
UDFFlushCompletion(
PDEVICE_OBJECT PtrDeviceObject,
PIRP Irp,
PVOID Context
)
{
// NTSTATUS RC = STATUS_SUCCESS;
UDFPrint(("UDFFlushCompletion: \n"));
if (Irp->PendingReturned) {
IoMarkIrpPending(Irp);
}
if (Irp->IoStatus.Status == STATUS_INVALID_DEVICE_REQUEST) {
// cannot do much here, can we?
Irp->IoStatus.Status = STATUS_SUCCESS;
}
return(STATUS_SUCCESS);
} // end UDFFlushCompletion()
/*
Check if we should break FlushTree process
*/
BOOLEAN
UDFFlushIsBreaking(
IN PVCB Vcb,
IN ULONG FlushFlags
)
{
BOOLEAN ret_val = FALSE;
// if(!(FlushFlags & UDF_FLUSH_FLAGS_BREAKABLE))
return FALSE;
UDFAcquireResourceExclusive(&(Vcb->FlushResource),TRUE);
ret_val = (Vcb->VCBFlags & UDF_VCB_FLAGS_FLUSH_BREAK_REQ) ? TRUE : FALSE;
Vcb->VCBFlags &= ~UDF_VCB_FLAGS_FLUSH_BREAK_REQ;
UDFReleaseResource(&(Vcb->FlushResource));
return ret_val;
} // end UDFFlushIsBreaking()
/*
Signal FlushTree break request. Note, this is
treated as recommendation only
*/
VOID
UDFFlushTryBreak(
IN PVCB Vcb
)
{
UDFAcquireResourceExclusive(&(Vcb->FlushResource),TRUE);
Vcb->VCBFlags |= UDF_VCB_FLAGS_FLUSH_BREAK_REQ;
UDFReleaseResource(&(Vcb->FlushResource));
} // end UDFFlushTryBreak()