protos.h File Reference

#include "mem.h"
#include "namesup.h"

Include dependency graph for protos.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	UDF_CLOSE_NTREQFCB_DELETED   0x01
#define	UDF_CLOSE_FCB_DELETED   0x02
#define	UDFCloseAllDelayedInDir(Vcb, FI)    UDFCloseAllXXXDelayedInDir(Vcb,FI,FALSE);
#define	UDFCloseAllSystemDelayedInDir(Vcb, FI)    UDFCloseAllXXXDelayedInDir(Vcb,FI,TRUE);
#define	UDFRemoveFromDelayedQueue(Fcb)    UDFCloseAllDelayedInDir((Fcb)->Vcb, (Fcb)->FileInfo)
#define	UDFRemoveFromSystemDelayedQueue(Fcb)    UDFCloseAllSystemDelayedInDir((Fcb)->Vcb, (Fcb)->FileInfo)
#define	UDFRemoveFileId__(Vcb, fi)    UDFRemoveFileId(Vcb, UDFGetNTFileId(Vcb, fi, &(fi->Fcb->FCBName->ObjectName)));
#define	UDFZeroDataEx(NtReqFcb, Offset, Length, CanWait, Vcb, FileObject)    UDFPurgeCacheEx_(NtReqFcb, Offset, Length, CanWait, Vcb, FileObject)
#define	UDFPurgeCacheEx(NtReqFcb, Offset, Length, CanWait, Vcb, FileObject)    UDFPurgeCacheEx_(NtReqFcb, Offset, Length, CanWait, Vcb, FileObject)

Functions
NTSTATUS NTAPI	UDFCreate (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	UDFCommonCreate (IN PtrUDFIrpContext PtrIrpContext, IN PIRP Irp)
NTSTATUS	UDFFirstOpenFile (IN PVCB Vcb, IN PFILE_OBJECT PtrNewFileObject, OUT PtrUDFFCB *PtrNewFcb, IN PUDF_FILE_INFO RelatedFileInfo, IN PUDF_FILE_INFO NewFileInfo, IN PUNICODE_STRING LocalPath, IN PUNICODE_STRING CurName)
NTSTATUS	UDFOpenFile (IN PVCB Vcb, IN PFILE_OBJECT PtrNewFileObject, IN PtrUDFFCB PtrNewFcb)
NTSTATUS	UDFInitializeFCB (IN PtrUDFFCB PtrNewFcb, IN PVCB Vcb, IN PtrUDFObjectName PtrObjectName, IN ULONG Flags, IN PFILE_OBJECT FileObject)
NTSTATUS NTAPI	UDFCleanup (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	UDFCommonCleanup (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
NTSTATUS	UDFCloseFileInfoChain (IN PVCB Vcb, IN PUDF_FILE_INFO fi, IN ULONG TreeLength, IN BOOLEAN VcbAcquired)
NTSTATUS NTAPI	UDFClose (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	UDFCommonClose (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
ULONG	UDFCleanUpFcbChain (IN PVCB Vcb, IN PUDF_FILE_INFO fi, IN ULONG TreeLength, IN BOOLEAN VcbAcquired)
VOID	UDFCloseAllDelayed (PVCB Vcb)
VOID NTAPI	UDFDelayedClose (PVOID unused=NULL)
NTSTATUS	UDFCloseAllXXXDelayedInDir (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN BOOLEAN System)
NTSTATUS	UDFQueueDelayedClose (PtrUDFIrpContext IrpContext, PtrUDFFCB Fcb)
NTSTATUS NTAPI	UDFDirControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	UDFCommonDirControl (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
NTSTATUS NTAPI	UDFQueryDirectory (PtrUDFIrpContext PtrIrpContext, PIRP Irp, PIO_STACK_LOCATION IrpSp, PFILE_OBJECT FileObject, PtrUDFFCB Fcb, PtrUDFCCB Ccb)
NTSTATUS NTAPI	UDFNotifyChangeDirectory (PtrUDFIrpContext PtrIrpContext, PIRP Irp, PIO_STACK_LOCATION IrpSp, PFILE_OBJECT FileObject, PtrUDFFCB Fcb, PtrUDFCCB Ccb)
NTSTATUS NTAPI	UDFDeviceControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	UDFCommonDeviceControl (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
NTSTATUS NTAPI	UDFDevIoctlCompletion (PDEVICE_OBJECT PtrDeviceObject, PIRP Irp, PVOID Context)
NTSTATUS NTAPI	UDFHandleQueryPath (PVOID BufferPointer)
BOOLEAN NTAPI	UDFFastIoCheckIfPossible (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, IN BOOLEAN CheckForReadOperation, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
FAST_IO_POSSIBLE NTAPI	UDFIsFastIoPossible (IN PtrUDFFCB Fcb)
BOOLEAN NTAPI	UDFFastIoQueryBasicInfo (IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, OUT PFILE_BASIC_INFORMATION Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
BOOLEAN NTAPI	UDFFastIoQueryStdInfo (IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, OUT PFILE_STANDARD_INFORMATION Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
VOID NTAPI	UDFFastIoAcqCreateSec (IN PFILE_OBJECT FileObject)
VOID NTAPI	UDFFastIoRelCreateSec (IN PFILE_OBJECT FileObject)
BOOLEAN NTAPI	UDFAcqLazyWrite (IN PVOID Context, IN BOOLEAN Wait)
VOID NTAPI	UDFRelLazyWrite (IN PVOID Context)
BOOLEAN NTAPI	UDFAcqReadAhead (IN PVOID Context, IN BOOLEAN Wait)
VOID NTAPI	UDFRelReadAhead (IN PVOID Context)
VOID NTAPI	UDFDriverUnload (IN PDRIVER_OBJECT DriverObject)
NTSTATUS NTAPI	UDFFileInfo (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	UDFCommonFileInfo (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
NTSTATUS	UDFGetBasicInformation (IN PFILE_OBJECT FileObject, IN PtrUDFFCB Fcb, IN PFILE_BASIC_INFORMATION PtrBuffer, IN OUT LONG *PtrReturnedLength)
NTSTATUS	UDFGetNetworkInformation (IN PtrUDFFCB Fcb, IN PFILE_NETWORK_OPEN_INFORMATION PtrBuffer, IN OUT PLONG PtrReturnedLength)
NTSTATUS	UDFGetStandardInformation (IN PtrUDFFCB Fcb, IN PFILE_STANDARD_INFORMATION PtrBuffer, IN OUT PLONG PtrReturnedLength)
NTSTATUS	UDFGetInternalInformation (PtrUDFIrpContext PtrIrpContext, IN PtrUDFFCB Fcb, IN PtrUDFCCB Ccb, IN PFILE_INTERNAL_INFORMATION PtrBuffer, IN OUT PLONG PtrReturnedLength)
NTSTATUS	UDFGetEaInformation (PtrUDFIrpContext PtrIrpContext, IN PtrUDFFCB Fcb, IN PFILE_EA_INFORMATION PtrBuffer, IN OUT PLONG PtrReturnedLength)
NTSTATUS	UDFGetFullNameInformation (IN PFILE_OBJECT FileObject, IN PFILE_NAME_INFORMATION PtrBuffer, IN OUT PLONG PtrReturnedLength)
NTSTATUS	UDFGetAltNameInformation (IN PtrUDFFCB Fcb, IN PFILE_NAME_INFORMATION PtrBuffer, IN OUT PLONG PtrReturnedLength)
NTSTATUS	UDFGetPositionInformation (IN PFILE_OBJECT FileObject, IN PFILE_POSITION_INFORMATION PtrBuffer, IN OUT PLONG PtrReturnedLength)
NTSTATUS	UDFGetFileStreamInformation (IN PtrUDFFCB Fcb, IN PFILE_STREAM_INFORMATION PtrBuffer, IN OUT PLONG PtrReturnedLength)
NTSTATUS	UDFSetBasicInformation (IN PtrUDFFCB Fcb, IN PtrUDFCCB Ccb, IN PFILE_OBJECT FileObject, IN PFILE_BASIC_INFORMATION PtrBuffer)
NTSTATUS	UDFMarkStreamsForDeletion (IN PVCB Vcb, IN PtrUDFFCB Fcb, IN BOOLEAN ForDel)
NTSTATUS	UDFSetDispositionInformation (IN PtrUDFFCB Fcb, IN PtrUDFCCB Ccb, IN PVCB Vcb, IN PFILE_OBJECT FileObject, IN BOOLEAN Delete)
NTSTATUS	UDFSetAllocationInformation (IN PtrUDFFCB Fcb, IN PtrUDFCCB Ccb, IN PVCB Vcb, IN PFILE_OBJECT FileObject, IN PtrUDFIrpContext PtrIrpContext, IN PIRP Irp, IN PFILE_ALLOCATION_INFORMATION PtrBuffer)
NTSTATUS	UDFSetEOF (IN PIO_STACK_LOCATION PtrSp, IN PtrUDFFCB Fcb, IN PtrUDFCCB Ccb, IN PVCB Vcb, IN PFILE_OBJECT FileObject, IN PIRP Irp, IN PFILE_END_OF_FILE_INFORMATION PtrBuffer)
NTSTATUS	UDFRename (IN PIO_STACK_LOCATION IrpSp, IN PtrUDFFCB Fcb, IN PtrUDFCCB Ccb, IN PFILE_OBJECT FileObject, IN PFILE_RENAME_INFORMATION PtrBuffer)
NTSTATUS	UDFStoreFileId (IN PVCB Vcb, IN PtrUDFCCB Ccb, IN PUDF_FILE_INFO fi, IN LONGLONG Id)
NTSTATUS	UDFRemoveFileId (IN PVCB Vcb, IN LONGLONG Id)
VOID	UDFReleaseFileIdCache (IN PVCB Vcb)
NTSTATUS	UDFGetOpenParamsByFileId (IN PVCB Vcb, IN LONGLONG Id, OUT PUNICODE_STRING *FName, OUT BOOLEAN *CaseSens)
NTSTATUS	UDFHardLink (IN PIO_STACK_LOCATION PtrSp, IN PtrUDFFCB Fcb1, IN PtrUDFCCB Ccb1, IN PFILE_OBJECT FileObject1, IN PFILE_LINK_INFORMATION PtrBuffer)
NTSTATUS NTAPI	UDFFlush (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	UDFCommonFlush (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
ULONG	UDFFlushAFile (PtrUDFFCB Fcb, PtrUDFCCB Ccb, PIO_STATUS_BLOCK PtrIoStatus, IN ULONG FlushFlags=0)
ULONG	UDFFlushADirectory (IN PVCB Vcb, IN PUDF_FILE_INFO FI, OUT PIO_STATUS_BLOCK PtrIoStatus, ULONG FlushFlags=0)
ULONG	UDFFlushLogicalVolume (PtrUDFIrpContext PtrIrpContext, PIRP Irp, PVCB Vcb, ULONG FlushFlags=0)
NTSTATUS NTAPI	UDFFlushCompletion (PDEVICE_OBJECT PtrDeviceObject, PIRP Irp, PVOID Context)
BOOLEAN	UDFFlushIsBreaking (IN PVCB Vcb, IN ULONG FlushFlags=0)
VOID	UDFFlushTryBreak (IN PVCB Vcb)
NTSTATUS NTAPI	UDFFSControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	UDFCommonFSControl (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
NTSTATUS NTAPI	UDFUserFsCtrlRequest (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
NTSTATUS NTAPI	UDFMountVolume (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
NTSTATUS	UDFStartEjectWaiter (IN PVCB Vcb)
VOID	UDFScanForDismountedVcb (IN PtrUDFIrpContext IrpContext)
NTSTATUS	UDFCompleteMount (IN PVCB Vcb)
VOID	UDFCloseResidual (IN PVCB Vcb)
VOID	UDFCleanupVCB (IN PVCB Vcb)
NTSTATUS	UDFIsVolumeMounted (IN PtrUDFIrpContext IrpContext, IN PIRP Irp)
NTSTATUS	UDFIsVolumeDirty (IN PtrUDFIrpContext IrpContext, IN PIRP Irp)
NTSTATUS	UDFGetStatistics (IN PtrUDFIrpContext IrpContext, IN PIRP Irp)
NTSTATUS	UDFLockVolume (IN PtrUDFIrpContext IrpContext, IN PIRP Irp, IN ULONG PID=-1)
NTSTATUS	UDFUnlockVolume (IN PtrUDFIrpContext IrpContext, IN PIRP Irp, IN ULONG PID=-1)
NTSTATUS	UDFIsPathnameValid (IN PtrUDFIrpContext IrpContext, IN PIRP Irp)
NTSTATUS	UDFDismountVolume (IN PtrUDFIrpContext IrpContext, IN PIRP Irp)
NTSTATUS	UDFGetVolumeBitmap (IN PtrUDFIrpContext IrpContext, IN PIRP Irp)
NTSTATUS	UDFGetRetrievalPointers (IN PtrUDFIrpContext IrpContext, IN PIRP Irp, IN ULONG Special)
NTSTATUS	UDFInvalidateVolumes (IN PtrUDFIrpContext IrpContext, IN PIRP Irp)
NTSTATUS NTAPI	UDFLockControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	UDFCommonLockControl (IN PtrUDFIrpContext PtrIrpContext, IN PIRP Irp)
BOOLEAN NTAPI	UDFFastLock (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, PEPROCESS ProcessId, ULONG Key, BOOLEAN FailImmediately, BOOLEAN ExclusiveLock, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
BOOLEAN NTAPI	UDFFastUnlockSingle (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, PEPROCESS ProcessId, ULONG Key, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
BOOLEAN NTAPI	UDFFastUnlockAll (IN PFILE_OBJECT FileObject, PEPROCESS ProcessId, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
BOOLEAN NTAPI	UDFFastUnlockAllByKey (IN PFILE_OBJECT FileObject, PEPROCESS ProcessId, ULONG Key, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
NTSTATUS	UDFInitializeZones (VOID)
VOID	UDFDestroyZones (VOID)
BOOLEAN __fastcall	UDFIsIrpTopLevel (PIRP Irp)
long	UDFExceptionFilter (PtrUDFIrpContext PtrIrpContext, PEXCEPTION_POINTERS PtrExceptionPointers)
NTSTATUS	UDFExceptionHandler (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
VOID	UDFLogEvent (NTSTATUS UDFEventLogId, NTSTATUS RC)
PtrUDFObjectName	UDFAllocateObjectName (VOID)
VOID __fastcall	UDFReleaseObjectName (PtrUDFObjectName PtrObjectName)
PtrUDFCCB	UDFAllocateCCB (VOID)
VOID __fastcall	UDFReleaseCCB (PtrUDFCCB Ccb)
VOID __fastcall	UDFCleanUpCCB (PtrUDFCCB Ccb)
PtrUDFFCB	UDFAllocateFCB (VOID)
__inline VOID	UDFReleaseFCB (PtrUDFFCB Fcb)
VOID __fastcall	UDFCleanUpFCB (PtrUDFFCB Fcb)
PtrUDFIrpContext	UDFAllocateIrpContext (PIRP Irp, PDEVICE_OBJECT PtrTargetDeviceObject)
VOID	UDFReleaseIrpContext (PtrUDFIrpContext PtrIrpContext)
NTSTATUS	UDFPostRequest (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
VOID NTAPI	UDFCommonDispatch (VOID *Context)
NTSTATUS	UDFInitializeVCB (PDEVICE_OBJECT PtrVolumeDeviceObject, PDEVICE_OBJECT PtrTargetDeviceObject, PVPB PtrVPB)
VOID	UDFReadRegKeys (PVCB Vcb, BOOLEAN Update, BOOLEAN UseCfg)
ULONG	UDFGetRegParameter (IN PVCB Vcb, IN PCWSTR Name, IN ULONG DefValue=0)
ULONG	UDFGetCfgParameter (IN PVCB Vcb, IN PCWSTR Name, IN ULONG DefValue)
VOID	UDFReleaseVCB (PVCB Vcb)
ULONG	UDFRegCheckParameterValue (IN PUNICODE_STRING RegistryPath, IN PCWSTR Name, IN PUNICODE_STRING PtrVolumePath, IN PCWSTR DefaultPath, IN ULONG DefValue=0)
VOID	UDFInitializeIrpContextFromLite (OUT PtrUDFIrpContext *IrpContext, IN PtrUDFIrpContextLite IrpContextLite)
NTSTATUS	UDFInitializeIrpContextLite (OUT PtrUDFIrpContextLite *IrpContextLite, IN PtrUDFIrpContext IrpContext, IN PtrUDFFCB Fcb)
NTSTATUS NTAPI	UDFQuerySetEA (PDEVICE_OBJECT DeviceObject, PIRP Irp)
ULONG	UDFIsResourceAcquired (IN PERESOURCE Resource)
BOOLEAN	UDFAcquireResourceExclusiveWithCheck (IN PERESOURCE Resource)
BOOLEAN	UDFAcquireResourceSharedWithCheck (IN PERESOURCE Resource)
NTSTATUS	UDFWCacheErrorHandler (IN PVOID Context, IN PWCACHE_ERROR_CONTEXT ErrorInfo)
NTSTATUS	UDFPnp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
OSSTATUS NTAPI	UDFRead (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	UDFPostStackOverflowRead (IN PtrUDFIrpContext PtrIrpContext, IN PIRP Irp, IN PtrUDFFCB Fcb)
VOID NTAPI	UDFStackOverflowRead (IN PVOID Context, IN PKEVENT Event)
NTSTATUS	UDFCommonRead (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
PVOID	UDFGetCallersBuffer (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
NTSTATUS	UDFLockCallersBuffer (PtrUDFIrpContext PtrIrpContext, PIRP Irp, BOOLEAN IsReadOperation, uint32 Length)
NTSTATUS	UDFUnlockCallersBuffer (PtrUDFIrpContext PtrIrpContext, PIRP Irp, PVOID SystemBuffer)
VOID	UDFMdlComplete (PtrUDFIrpContext PtrIrpContext, PIRP Irp, PIO_STACK_LOCATION IrpSp, BOOLEAN ReadCompletion)
NTSTATUS	UDFGetSecurity (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	UDFSetSecurity (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	UDFCommonGetSecurity (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
NTSTATUS	UDFCommonSetSecurity (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
NTSTATUS	UDFReadSecurity (IN PVCB Vcb, IN PtrUDFFCB Fcb, IN PSECURITY_DESCRIPTOR *SecurityDesc)
NTSTATUS	UDFAssignAcl (IN PVCB Vcb, IN PFILE_OBJECT FileObject, IN PtrUDFFCB Fcb, IN PtrUDFNTRequiredFCB NtReqFcb)
VOID	UDFDeassignAcl (IN PtrUDFNTRequiredFCB NtReqFcb, IN BOOLEAN AutoInherited)
NTSTATUS	UDFWriteSecurity (IN PVCB Vcb, IN PtrUDFFCB Fcb, IN PSECURITY_DESCRIPTOR *SecurityDesc)
NTSTATUS	UDFCheckAccessRights (PFILE_OBJECT FileObject, PACCESS_STATE AccessState, PtrUDFFCB Fcb, PtrUDFCCB Ccb, ACCESS_MASK DesiredAccess, USHORT ShareAccess)
NTSTATUS	UDFSetAccessRights (PFILE_OBJECT FileObject, PACCESS_STATE AccessState, PtrUDFFCB Fcb, PtrUDFCCB Ccb, ACCESS_MASK DesiredAccess, USHORT ShareAccess)
NTSTATUS NTAPI	UDFShutdown (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	UDFCommonShutdown (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
BOOLEAN	UDFDebugAcquireResourceSharedLite (IN PERESOURCE Resource, IN BOOLEAN Wait, ULONG BugCheckId, ULONG Line)
BOOLEAN	UDFDebugAcquireSharedStarveExclusive (IN PERESOURCE Resource, IN BOOLEAN Wait, ULONG BugCheckId, ULONG Line)
BOOLEAN	UDFDebugAcquireResourceExclusiveLite (IN PERESOURCE Resource, IN BOOLEAN Wait, ULONG BugCheckId, ULONG Line)
VOID	UDFDebugReleaseResourceForThreadLite (IN PERESOURCE Resource, IN ERESOURCE_THREAD ResourceThreadId, ULONG BugCheckId, ULONG Line)
VOID	UDFDebugDeleteResource (IN PERESOURCE Resource, IN ERESOURCE_THREAD ResourceThreadId, ULONG BugCheckId, ULONG Line)
NTSTATUS	UDFDebugInitializeResourceLite (IN PERESOURCE Resource, IN ERESOURCE_THREAD ResourceThreadId, ULONG BugCheckId, ULONG Line)
VOID	UDFDebugConvertExclusiveToSharedLite (IN PERESOURCE Resource, IN ERESOURCE_THREAD ResourceThreadId, ULONG BugCheckId, ULONG Line)
BOOLEAN	UDFDebugAcquireSharedWaitForExclusive (IN PERESOURCE Resource, IN BOOLEAN Wait, ULONG BugCheckId, ULONG Line)
LONG	UDFDebugInterlockedIncrement (IN PLONG addr, ULONG BugCheckId, ULONG Line)
LONG	UDFDebugInterlockedDecrement (IN PLONG addr, ULONG BugCheckId, ULONG Line)
LONG	UDFDebugInterlockedExchangeAdd (IN PLONG addr, IN LONG i, ULONG BugCheckId, ULONG Line)
NTSTATUS NTAPI	DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
VOID NTAPI	UDFInitializeFunctionPointers (PDRIVER_OBJECT DriverObject)
VOID NTAPI	UDFFsNotification (IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN FsActive)
BOOLEAN	UDFGetInstallVersion (PULONG iVer)
BOOLEAN	UDFGetInstallTime (PULONG iTime)
BOOLEAN	UDFGetTrialEnd (PULONG iTrial)
NTSTATUS	UDFVerifyVcb (IN PtrUDFIrpContext IrpContext, IN PVCB Vcb)
NTSTATUS	UDFVerifyVolume (IN PIRP Irp)
NTSTATUS	UDFPerformVerify (IN PtrUDFIrpContext IrpContext, IN PIRP Irp, IN PDEVICE_OBJECT DeviceToVerify)
BOOLEAN	UDFCheckForDismount (IN PtrUDFIrpContext IrpContext, IN PVCB Vcb, IN BOOLEAN VcbAcquired)
BOOLEAN	UDFDismountVcb (IN PVCB Vcb, IN BOOLEAN VcbAcquired)
NTSTATUS	UDFCompareVcb (IN PVCB OldVcb, IN PVCB NewVcb, IN BOOLEAN PhysicalOnly)
NTSTATUS NTAPI	UDFQueryVolInfo (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	UDFCommonQueryVolInfo (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
NTSTATUS NTAPI	UDFSetVolInfo (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	UDFCommonSetVolInfo (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
NTSTATUS NTAPI	UDFWrite (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	UDFCommonWrite (PtrUDFIrpContext PtrIrpContext, PIRP Irp)
VOID NTAPI	UDFDeferredWriteCallBack (VOID *Context1, VOID *Context2)
VOID	UDFPurgeCacheEx_ (PtrUDFNTRequiredFCB NtReqFcb, LONGLONG Offset, LONGLONG Length, BOOLEAN CanWait, PVCB Vcb, PFILE_OBJECT FileObject)

Macro Definition Documentation

UDF_CLOSE_FCB_DELETED

#define UDF_CLOSE_FCB_DELETED   0x02

Definition at line 81 of file protos.h.

UDF_CLOSE_NTREQFCB_DELETED

#define UDF_CLOSE_NTREQFCB_DELETED   0x01

Definition at line 80 of file protos.h.

UDFCloseAllDelayedInDir

#define UDFCloseAllDelayedInDir	(		Vcb,
			FI
	)		UDFCloseAllXXXDelayedInDir(Vcb,FI,FALSE);

Definition at line 96 of file protos.h.

UDFCloseAllSystemDelayedInDir

#define UDFCloseAllSystemDelayedInDir	(		Vcb,
			FI
	)		UDFCloseAllXXXDelayedInDir(Vcb,FI,TRUE);

Definition at line 99 of file protos.h.

UDFPurgeCacheEx

#define UDFPurgeCacheEx	(		NtReqFcb,
			Offset,
			Length,
			CanWait,
			Vcb,
			FileObject
	)		UDFPurgeCacheEx_(NtReqFcb, Offset, Length, CanWait, Vcb, FileObject)

Definition at line 1148 of file protos.h.

UDFRemoveFileId__

#define UDFRemoveFileId__	(		Vcb,
			fi
	)		UDFRemoveFileId(Vcb, UDFGetNTFileId(Vcb, fi, &(fi->Fcb->FCBName->ObjectName)));

Definition at line 407 of file protos.h.

UDFRemoveFromDelayedQueue

#define UDFRemoveFromDelayedQueue

(

Fcb

)

UDFCloseAllDelayedInDir((Fcb)->Vcb, (Fcb)->FileInfo)

Definition at line 106 of file protos.h.

UDFRemoveFromSystemDelayedQueue

#define UDFRemoveFromSystemDelayedQueue

(

Fcb

)

UDFCloseAllSystemDelayedInDir((Fcb)->Vcb, (Fcb)->FileInfo)

Definition at line 109 of file protos.h.

UDFZeroDataEx

#define UDFZeroDataEx	(		NtReqFcb,
			Offset,
			Length,
			CanWait,
			Vcb,
			FileObject
	)		UDFPurgeCacheEx_(NtReqFcb, Offset, Length, CanWait, Vcb, FileObject)

Definition at line 1146 of file protos.h.

Function Documentation

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	PDRIVER_OBJECT	DriverObject,
		PUNICODE_STRING	RegistryPath
	)

Definition at line 16 of file battc.c.

{
    DPRINT("Battery class driver initialized\n");
 
    return STATUS_SUCCESS;
}

UDFAcqLazyWrite()

BOOLEAN NTAPI UDFAcqLazyWrite	(	IN PVOID	Context,
		IN BOOLEAN	Wait
	)

Definition at line 423 of file fastio.cpp.

{
    // The context is whatever we passed to the Cache Manager when invoking
    // the CcInitializeCacheMaps() function. In the case of the UDF FSD
    // implementation, this context is a pointer to the NT_REQ_FCB structure.
    PtrUDFNTRequiredFCB NtReqFcb = (PtrUDFNTRequiredFCB)Context;
 
    MmPrint(("  UDFAcqLazyWrite()\n"));
 
    // Acquire the PagingIoResource in the NT_REQ_FCB exclusively. Then, set the
    // lazy-writer thread id in the NT_REQ_FCB structure for identification
    // when an actual write request is received by the FSD.
    // Note: The lazy-writer typically always supplies WAIT set to TRUE.
    if (!UDFAcquireResourceExclusive(&(NtReqFcb->PagingIoResource), Wait))
        return FALSE;
 
    // Now, set the lazy-writer thread id.
    ASSERT(!(NtReqFcb->LazyWriterThreadID));
    NtReqFcb->LazyWriterThreadID = HandleToUlong(PsGetCurrentThreadId());
 
    ASSERT(IoGetTopLevelIrp() == NULL);
    IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
 
    // If our FSD needs to perform some special preparations in anticipation
    // of receving a lazy-writer request, do so now.
    return TRUE;
} // end UDFAcqLazyWrite()

Referenced by UDFInitializeFunctionPointers().

UDFAcqReadAhead()

BOOLEAN NTAPI UDFAcqReadAhead	(	IN PVOID	Context,
		IN BOOLEAN	Wait
	)

Definition at line 514 of file fastio.cpp.

{
    // The context is whatever we passed to the Cache Manager when invoking
    // the CcInitializeCacheMaps() function. In the case of the UDF FSD
    // implementation, this context is a pointer to the NT_REQ_FCB structure.
#define NtReqFcb ((PtrUDFNTRequiredFCB)Context)
 
    MmPrint(("  AcqForReadAhead()\n"));
 
    // Acquire the MainResource in the NT_REQ_FCB shared.
    // Note: The read-ahead thread typically always supplies WAIT set to TRUE.
    UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
    if (!UDFAcquireResourceShared(&(NtReqFcb->MainResource), Wait))
        return FALSE;
 
    ASSERT(IoGetTopLevelIrp() == NULL);
    IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
 
    return TRUE;
#undef NtReqFcb
 
} // end UDFAcqReadAhead()

Referenced by UDFInitializeFunctionPointers().

UDFAcquireResourceExclusiveWithCheck()

BOOLEAN UDFAcquireResourceExclusiveWithCheck

(

IN PERESOURCE

Resource

)

Definition at line 2529 of file misc.cpp.

{
    ULONG ReAcqRes =
        ExIsResourceAcquiredExclusiveLite(Resource) ? 1 :
        (ExIsResourceAcquiredSharedLite(Resource) ? 2 : 0);
    if(ReAcqRes) {
        UDFPrint(("UDFAcquireResourceExclusiveWithCheck: ReAcqRes, %x\n", ReAcqRes));
    } else {
//        BrutePoint();
    }
 
    if(ReAcqRes == 1) {
        // OK
    } else
    if(ReAcqRes == 2) {
        UDFPrint(("UDFAcquireResourceExclusiveWithCheck: !!! Shared !!!\n"));
        //BrutePoint();
    } else {
        UDFAcquireResourceExclusive(Resource, TRUE);
        return TRUE;
    }
    return FALSE;
} // end UDFAcquireResourceExclusiveWithCheck()

Referenced by UDFCommonCleanup(), UDFCommonWrite(), UDFSetAllocationInformation(), UDFSetEOF(), and UDFTSendIOCTL().

UDFAcquireResourceSharedWithCheck()

BOOLEAN UDFAcquireResourceSharedWithCheck

(

IN PERESOURCE

Resource

)

Definition at line 2556 of file misc.cpp.

{
    ULONG ReAcqRes =
        ExIsResourceAcquiredExclusiveLite(Resource) ? 1 :
        (ExIsResourceAcquiredSharedLite(Resource) ? 2 : 0);
    if(ReAcqRes) {
        UDFPrint(("UDFAcquireResourceSharedWithCheck: ReAcqRes, %x\n", ReAcqRes));
/*    } else {
        BrutePoint();*/
    }
 
    if(ReAcqRes == 2) {
        // OK
    } else
    if(ReAcqRes == 1) {
        UDFPrint(("UDFAcquireResourceSharedWithCheck: Exclusive\n"));
        //BrutePoint();
    } else {
        UDFAcquireResourceShared(Resource, TRUE);
        return TRUE;
    }
    return FALSE;
} // end UDFAcquireResourceSharedWithCheck()

Referenced by UDFCommonRead().

UDFAllocateCCB()

PtrUDFCCB UDFAllocateCCB

(

VOID

)

Definition at line 707 of file misc.cpp.

{
    PtrUDFCCB                   Ccb = NULL;
    BOOLEAN                     AllocatedFromZone = TRUE;
    KIRQL                       CurrentIrql;
 
    // first, __try to allocate out of the zone
    KeAcquireSpinLock(&(UDFGlobalData.ZoneAllocationSpinLock), &CurrentIrql);
    if (!ExIsFullZone(&(UDFGlobalData.CCBZoneHeader))) {
        // we have enough memory
        Ccb = (PtrUDFCCB)ExAllocateFromZone(&(UDFGlobalData.CCBZoneHeader));
 
        // release the spinlock
        KeReleaseSpinLock(&(UDFGlobalData.ZoneAllocationSpinLock), CurrentIrql);
    } else {
        // release the spinlock
        KeReleaseSpinLock(&(UDFGlobalData.ZoneAllocationSpinLock), CurrentIrql);
 
        // if we failed to obtain from the zone, get it directly from the VMM
        Ccb = (PtrUDFCCB)MyAllocatePool__(NonPagedPool, UDFQuadAlign(sizeof(UDFCCB)));
        AllocatedFromZone = FALSE;
//        UDFPrint(("    CCB allocated @%x\n",Ccb));
    }
 
    if (!Ccb) {
        return NULL;
    }
 
    // zero out the allocated memory block
    RtlZeroMemory(Ccb, UDFQuadAlign(sizeof(UDFCCB)));
 
    // set up some fields ...
    Ccb->NodeIdentifier.NodeType = UDF_NODE_TYPE_CCB;
    Ccb->NodeIdentifier.NodeSize = UDFQuadAlign(sizeof(UDFCCB));
 
 
    if (!AllocatedFromZone) {
        UDFSetFlag(Ccb->CCBFlags, UDF_CCB_NOT_FROM_ZONE);
    }
 
    UDFPrint(("UDFAllocateCCB: %x\n", Ccb));
    return(Ccb);
} // end UDFAllocateCCB()

Referenced by UDFOpenFile().

UDFAllocateFCB()

PtrUDFFCB UDFAllocateFCB

(

VOID

)

Definition at line 854 of file misc.cpp.

{
    PtrUDFFCB                   Fcb = NULL;
 
    Fcb = (PtrUDFFCB)MyAllocatePool__(UDF_FCB_MT, UDFQuadAlign(sizeof(UDFFCB)));
 
    if (!Fcb) {
        return NULL;
    }
 
    // zero out the allocated memory block
    RtlZeroMemory(Fcb, UDFQuadAlign(sizeof(UDFFCB)));
 
    // set up some fields ...
    Fcb->NodeIdentifier.NodeType = UDF_NODE_TYPE_FCB;
    Fcb->NodeIdentifier.NodeSize = UDFQuadAlign(sizeof(UDFFCB));
 
    UDFPrint(("UDFAllocateFCB: %x\n", Fcb));
    return(Fcb);
} // end UDFAllocateFCB()

Referenced by UDFBlankMount(), UDFCompleteMount(), and UDFFirstOpenFile().

UDFAllocateIrpContext()

PtrUDFIrpContext UDFAllocateIrpContext	(	PIRP	Irp,
		PDEVICE_OBJECT	PtrTargetDeviceObject
	)

Definition at line 985 of file misc.cpp.

{
    PtrUDFIrpContext            PtrIrpContext = NULL;
    BOOLEAN                     AllocatedFromZone = TRUE;
    KIRQL                       CurrentIrql;
    PIO_STACK_LOCATION          IrpSp = NULL;
 
    // first, __try to allocate out of the zone
    KeAcquireSpinLock(&(UDFGlobalData.ZoneAllocationSpinLock), &CurrentIrql);
    if (!ExIsFullZone(&(UDFGlobalData.IrpContextZoneHeader))) {
        // we have enough memory
        PtrIrpContext = (PtrUDFIrpContext)ExAllocateFromZone(&(UDFGlobalData.IrpContextZoneHeader));
 
        // release the spinlock
        KeReleaseSpinLock(&(UDFGlobalData.ZoneAllocationSpinLock), CurrentIrql);
    } else {
        // release the spinlock
        KeReleaseSpinLock(&(UDFGlobalData.ZoneAllocationSpinLock), CurrentIrql);
 
        // if we failed to obtain from the zone, get it directly from the VMM
        PtrIrpContext = (PtrUDFIrpContext)MyAllocatePool__(NonPagedPool, UDFQuadAlign(sizeof(UDFIrpContext)));
        AllocatedFromZone = FALSE;
    }
 
    // if we could not obtain the required memory, bug-check.
    //  Do NOT do this in your commercial driver, instead handle    the error gracefully ...
    if (!PtrIrpContext) {
        return NULL;
    }
 
#ifdef UDF_DBG
    IrpContextCounter++;
#endif //UDF_DBG
 
    // zero out the allocated memory block
    RtlZeroMemory(PtrIrpContext, UDFQuadAlign(sizeof(UDFIrpContext)));
 
    // set up some fields ...
    PtrIrpContext->NodeIdentifier.NodeType  = UDF_NODE_TYPE_IRP_CONTEXT;
    PtrIrpContext->NodeIdentifier.NodeSize  = UDFQuadAlign(sizeof(UDFIrpContext));
 
 
    PtrIrpContext->Irp = Irp;
    PtrIrpContext->TargetDeviceObject = PtrTargetDeviceObject;
 
    // copy over some fields from the IRP and set appropriate flag values
    if (Irp) {
        IrpSp = IoGetCurrentIrpStackLocation(Irp);
        ASSERT(IrpSp);
 
        PtrIrpContext->MajorFunction = IrpSp->MajorFunction;
        PtrIrpContext->MinorFunction = IrpSp->MinorFunction;
 
        // Often, a FSD cannot honor a request for asynchronous processing
        // of certain critical requests. For example, a "close" request on
        // a file object can typically never be deferred. Therefore, do not
        // be surprised if sometimes our FSD (just like all other FSD
        // implementations on the Windows NT system) has to override the flag
        // below.
        if (IrpSp->FileObject == NULL) {
            PtrIrpContext->IrpContextFlags |= UDF_IRP_CONTEXT_CAN_BLOCK;
        } else {
            if (IoIsOperationSynchronous(Irp)) {
                PtrIrpContext->IrpContextFlags |= UDF_IRP_CONTEXT_CAN_BLOCK;
            }
        }
    }
 
    if (!AllocatedFromZone) {
        UDFSetFlag(PtrIrpContext->IrpContextFlags, UDF_IRP_CONTEXT_NOT_FROM_ZONE);
    }
 
    // Are we top-level ? This information is used by the dispatching code
    // later (and also by the FSD dispatch routine)
    if (IoGetTopLevelIrp() != Irp) {
        // We are not top-level. Note this fact in the context structure
        UDFSetFlag(PtrIrpContext->IrpContextFlags, UDF_IRP_CONTEXT_NOT_TOP_LEVEL);
    }
 
    return(PtrIrpContext);
} // end UDFAllocateIrpContext()

Referenced by UDFCleanup(), UDFClose(), UDFCreate(), UDFDeviceControl(), UDFDirControl(), UDFFileInfo(), UDFFlush(), UDFFSControl(), UDFInitializeIrpContextFromLite(), UDFLockControl(), UDFPnp(), UDFQueryVolInfo(), UDFRead(), UDFSetVolInfo(), UDFShutdown(), and UDFWrite().

UDFAllocateObjectName()

PtrUDFObjectName UDFAllocateObjectName

(

VOID

)

Definition at line 611 of file misc.cpp.

{
    PtrUDFObjectName            PtrObjectName = NULL;
    BOOLEAN                     AllocatedFromZone = TRUE;
    KIRQL                       CurrentIrql;
 
    // first, __try to allocate out of the zone
    KeAcquireSpinLock(&(UDFGlobalData.ZoneAllocationSpinLock), &CurrentIrql);
    if (!ExIsFullZone(&(UDFGlobalData.ObjectNameZoneHeader))) {
        // we have enough memory
        PtrObjectName = (PtrUDFObjectName)ExAllocateFromZone(&(UDFGlobalData.ObjectNameZoneHeader));
 
        // release the spinlock
        KeReleaseSpinLock(&(UDFGlobalData.ZoneAllocationSpinLock), CurrentIrql);
    } else {
        // release the spinlock
        KeReleaseSpinLock(&(UDFGlobalData.ZoneAllocationSpinLock), CurrentIrql);
 
        // if we failed to obtain from the zone, get it directly from the VMM
        PtrObjectName = (PtrUDFObjectName)MyAllocatePool__(NonPagedPool, UDFQuadAlign(sizeof(UDFObjectName)));
        AllocatedFromZone = FALSE;
    }
 
    if (!PtrObjectName) {
        return NULL;
    }
 
    // zero out the allocated memory block
    RtlZeroMemory(PtrObjectName, UDFQuadAlign(sizeof(UDFObjectName)));
 
    // set up some fields ...
    PtrObjectName->NodeIdentifier.NodeType  = UDF_NODE_TYPE_OBJECT_NAME;
    PtrObjectName->NodeIdentifier.NodeSize  = UDFQuadAlign(sizeof(UDFObjectName));
 
 
    if (!AllocatedFromZone) {
        UDFSetFlag(PtrObjectName->ObjectNameFlags, UDF_OBJ_NAME_NOT_FROM_ZONE);
    }
 
    return(PtrObjectName);
} // end UDFAllocateObjectName()

Referenced by UDFBlankMount(), UDFCompleteMount(), UDFFirstOpenFile(), and UDFRename().

UDFAssignAcl()

NTSTATUS UDFAssignAcl	(	IN PVCB	Vcb,
		IN PFILE_OBJECT	FileObject,
		IN PtrUDFFCB	Fcb,
		IN PtrUDFNTRequiredFCB	NtReqFcb
	)

Definition at line 706 of file secursup.cpp.

{
    NTSTATUS RC = STATUS_SUCCESS;
#ifdef UDF_ENABLE_SECURITY
//    SECURITY_INFORMATION SecurityInformation;
 
//    UDFPrint(("  UDFAssignAcl\n"));
    if(!NtReqFcb->SecurityDesc) {
 
        PSECURITY_DESCRIPTOR ExplicitSecurity = NULL;
 
        if(UDFIsAStreamDir(Fcb->FileInfo) || UDFIsAStream(Fcb->FileInfo)) {
            // Stream/SDir security
            NtReqFcb->SecurityDesc = Fcb->FileInfo->ParentFile->Dloc->CommonFcb->SecurityDesc;
            return STATUS_SUCCESS;
        } else
        if(!Fcb->FileInfo) {
            // Volume security
            if(Vcb->RootDirFCB &&
               Vcb->RootDirFCB->FileInfo &&
               Vcb->RootDirFCB->FileInfo->Dloc &&
               Vcb->RootDirFCB->FileInfo->Dloc->CommonFcb) {
                RC = UDFInheritAcl(Vcb, &(Vcb->RootDirFCB->FileInfo->Dloc->CommonFcb->SecurityDesc), &ExplicitSecurity);
            } else {
                NtReqFcb->SecurityDesc = NULL;
                RC = STATUS_NO_SECURITY_ON_OBJECT;
            }
            return RC;
        }
 
        RC = UDFReadSecurity(Vcb, Fcb, &ExplicitSecurity);
        if(RC == STATUS_NO_SECURITY_ON_OBJECT) {
            if(!Fcb->FileInfo->ParentFile) {
                RC = UDFBuildFullControlAcl(Vcb, &ExplicitSecurity);
            } else {
                RC = UDFInheritAcl(Vcb, &(Fcb->FileInfo->ParentFile->Dloc->CommonFcb->SecurityDesc), &ExplicitSecurity);
            }
/*            if(NT_SUCCESS(RC)) {
                NtReqFcb->NtReqFCBFlags |= UDF_NTREQ_FCB_SD_MODIFIED;
            }*/
        }
        if(NT_SUCCESS(RC)) {
 
//            SecurityInformation = FULL_SECURITY_INFORMATION;
            NtReqFcb->SecurityDesc = ExplicitSecurity;
 
/*            RC = SeSetSecurityDescriptorInfo(FileObject,
                                          &SecurityInformation,
                                          ExplicitSecurity,
                                          &(NtReqFcb->SecurityDesc),
                                          NonPagedPool,
                                          IoGetFileObjectGenericMapping() );*/
 
        }
    }
#endif //UDF_ENABLE_SECURITY
    return RC;
} // end UDFAssignAcl()

Referenced by UDFCompleteMount(), and UDFLookUpAcl().

UDFCheckAccessRights()

NTSTATUS UDFCheckAccessRights	(	PFILE_OBJECT	FileObject,
		PACCESS_STATE	AccessState,
		PtrUDFFCB	Fcb,
		PtrUDFCCB	Ccb,
		ACCESS_MASK	DesiredAccess,
		USHORT	ShareAccess
	)

Definition at line 927 of file secursup.cpp.

{
    NTSTATUS RC;
    BOOLEAN ROCheck = FALSE;
#ifdef UDF_ENABLE_SECURITY
    BOOLEAN SecurityCheck;
    PSECURITY_DESCRIPTOR SecDesc;
    SECURITY_SUBJECT_CONTEXT SubjectContext;
    ACCESS_MASK LocalAccessMask;
#endif //UDF_ENABLE_SECURITY
 
    // Check attr compatibility
    ASSERT(Fcb);
    ASSERT(Fcb->Vcb);
#ifdef UDF_READ_ONLY_BUILD
    goto treat_as_ro;
#endif //UDF_READ_ONLY_BUILD
 
    if(Fcb->FCBFlags & UDF_FCB_READ_ONLY) {
        ROCheck = TRUE;
    } else
    if((Fcb->Vcb->origIntegrityType == INTEGRITY_TYPE_OPEN) &&
        Ccb && !(Ccb->CCBFlags & UDF_CCB_VOLUME_OPEN) &&
       (Fcb->Vcb->CompatFlags & UDF_VCB_IC_DIRTY_RO)) {
        AdPrint(("force R/O on dirty\n"));
        ROCheck = TRUE;
    }
    if(ROCheck) {
#ifdef UDF_READ_ONLY_BUILD
treat_as_ro:
#endif //UDF_READ_ONLY_BUILD
        ACCESS_MASK  DesiredAccessMask = 0;
 
        if(Fcb->Vcb->CompatFlags & UDF_VCB_IC_WRITE_IN_RO_DIR) {
            if(Fcb->FCBFlags & UDF_FCB_DIRECTORY) {
                DesiredAccessMask = (FILE_WRITE_EA |
                                     DELETE);
            } else {
                DesiredAccessMask = (FILE_WRITE_DATA |
                                     FILE_APPEND_DATA |
                                     FILE_WRITE_EA |
                                     DELETE);
            }
        } else {
                DesiredAccessMask = (FILE_WRITE_DATA |
                                     FILE_APPEND_DATA |
                                     FILE_WRITE_EA |
                                     FILE_DELETE_CHILD |
                                     FILE_ADD_SUBDIRECTORY |
                                     FILE_ADD_FILE |
                                     DELETE);
        }
        if(DesiredAccess & DesiredAccessMask)
            return STATUS_ACCESS_DENIED;
    }
#ifdef UDF_ENABLE_SECURITY
    // Check Security
    // NOTE: we should not perform security check if an empty DesiredAccess
    // was specified. AFAIU, SeAccessCheck() will return FALSE in this case.
    SecDesc = UDFLookUpAcl(Fcb->Vcb, FileObject, Fcb);
    if(SecDesc && DesiredAccess) {
        SeCaptureSubjectContext(&SubjectContext);
        SecurityCheck =
            SeAccessCheck(SecDesc,
                          &SubjectContext,
                          FALSE,
                          DesiredAccess,
                          Ccb ? Ccb->PreviouslyGrantedAccess : 0,
                          NULL,
                          IoGetFileObjectGenericMapping(),
                          UserMode,
                          Ccb ? &(Ccb->PreviouslyGrantedAccess) : &LocalAccessMask,
                          &RC);
        SeReleaseSubjectContext(&SubjectContext);
 
        if(!SecurityCheck) {
            return RC;
        } else
#endif //UDF_ENABLE_SECURITY
        if(DesiredAccess & ACCESS_SYSTEM_SECURITY) {
            if (!SeSinglePrivilegeCheck(SeExports->SeSecurityPrivilege, UserMode))
                return STATUS_ACCESS_DENIED;
            Ccb->PreviouslyGrantedAccess |= ACCESS_SYSTEM_SECURITY;
        }
#ifdef UDF_ENABLE_SECURITY
    }
#endif //UDF_ENABLE_SECURITY
    if(FileObject) {
        if (Fcb->OpenHandleCount) {
            // The FCB is currently in use by some thread.
            // We must check whether the requested access/share access
            // conflicts with the existing open operations.
            RC = IoCheckShareAccess(DesiredAccess, ShareAccess, FileObject,
                                            &(Fcb->NTRequiredFCB->FCBShareAccess), TRUE);
#ifndef UDF_ENABLE_SECURITY
            if(Ccb)
                Ccb->PreviouslyGrantedAccess |= DesiredAccess;
            IoUpdateShareAccess(FileObject, &(Fcb->NTRequiredFCB->FCBShareAccess));
#endif //UDF_ENABLE_SECURITY
        } else {
            IoSetShareAccess(DesiredAccess, ShareAccess, FileObject, &(Fcb->NTRequiredFCB->FCBShareAccess));
#ifndef UDF_ENABLE_SECURITY
            if(Ccb)
                Ccb->PreviouslyGrantedAccess = DesiredAccess;
#endif //UDF_ENABLE_SECURITY
            RC = STATUS_SUCCESS;
        }
    } else {
        // we get here if given file was opened for internal purposes
        RC = STATUS_SUCCESS;
    }
    return RC;
} // end UDFCheckAccessRights()

Referenced by UDFCommonCreate(), UDFDoesOSAllowFileToBeTargetForRename__(), UDFSetAccessRights(), and UDFSetDispositionInformation().

UDFCheckForDismount()

BOOLEAN UDFCheckForDismount	(	IN PtrUDFIrpContext	IrpContext,
		IN PVCB	Vcb,
		IN BOOLEAN	VcbAcquired
	)

Definition at line 629 of file verfysup.cpp.

{
    BOOLEAN VcbPresent = TRUE;
    KIRQL SavedIrql;
    BOOLEAN VcbAcquired;
    ULONG ResidualReferenceCount;
 
    UDFPrint(("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()

Referenced by UDFCommonClose(), UDFPerformVerify(), UDFPnpQueryRemove(), UDFPnpRemove(), UDFPnpSurpriseRemove(), and UDFScanForDismountedVcb().

UDFCleanup()

NTSTATUS NTAPI UDFCleanup	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 43 of file cleanup.cpp.

{
    NTSTATUS                RC = STATUS_SUCCESS;
    PtrUDFIrpContext        PtrIrpContext = NULL;
    BOOLEAN                 AreWeTopLevel = FALSE;
 
    TmPrint(("UDFCleanup\n"));
 
    FsRtlEnterFileSystem();
    ASSERT(DeviceObject);
    ASSERT(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 (UDFIsFSDevObj(DeviceObject)) {
        // this is a cleanup of the FSD itself
        Irp->IoStatus.Status = RC;
        Irp->IoStatus.Information = 0;
 
        if(UDFGlobalData.AutoFormatCount == IoGetCurrentIrpStackLocation(Irp)->FileObject) {
            UDFPrint(("Deregister Autoformat\n"));
            UDFGlobalData.AutoFormatCount = NULL;
        }
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        FsRtlExitFileSystem();
        return(RC);
    }
 
    // set the top level context
    AreWeTopLevel = UDFIsIrpTopLevel(Irp);
 
    _SEH2_TRY {
 
        // get an IRP context structure and issue the request
        PtrIrpContext = UDFAllocateIrpContext(Irp, DeviceObject);
        if(PtrIrpContext) {
            RC = UDFCommonCleanup(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 UDFCleanup()

Referenced by UDFInitializeFunctionPointers().

UDFCleanUpCCB()

VOID __fastcall UDFCleanUpCCB

(

PtrUDFCCB

Ccb

)

Definition at line 805 of file misc.cpp.

{
//    ASSERT(Ccb);
    if(!Ccb) return; // probably, we havn't allocated it...
    ASSERT(Ccb->NodeIdentifier.NodeType == UDF_NODE_TYPE_CCB);
 
    _SEH2_TRY {
        if(Ccb->Fcb) {
            UDFTouch(&(Ccb->Fcb->CcbListResource));
            UDFAcquireResourceExclusive(&(Ccb->Fcb->CcbListResource),TRUE);
            RemoveEntryList(&(Ccb->NextCCB));
            UDFReleaseResource(&(Ccb->Fcb->CcbListResource));
        } else {
            BrutePoint();
        }
 
        if (Ccb->DirectorySearchPattern) {
            if (Ccb->DirectorySearchPattern->Buffer) {
                MyFreePool__(Ccb->DirectorySearchPattern->Buffer);
                Ccb->DirectorySearchPattern->Buffer = NULL;
            }
 
            MyFreePool__(Ccb->DirectorySearchPattern);
            Ccb->DirectorySearchPattern = NULL;
        }
 
        UDFReleaseCCB(Ccb);
    } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
        BrutePoint();
    } _SEH2_END;
} // end UDFCleanUpCCB()

Referenced by UDFCommonClose(), and UDFCommonCreate().

UDFCleanUpFCB()

VOID __fastcall UDFCleanUpFCB

(

PtrUDFFCB

Fcb

)

Definition at line 908 of file misc.cpp.

{
    UDFPrint(("UDFCleanUpFCB: %x\n", Fcb));
    if(!Fcb) return;
 
    ASSERT(Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_FCB);
 
    _SEH2_TRY {
        // Deinitialize FCBName field
        if (Fcb->FCBName) {
            if(Fcb->FCBName->ObjectName.Buffer) {
                MyFreePool__(Fcb->FCBName->ObjectName.Buffer);
                Fcb->FCBName->ObjectName.Buffer = NULL;
#ifdef UDF_DBG
                Fcb->FCBName->ObjectName.Length =
                Fcb->FCBName->ObjectName.MaximumLength = 0;
#endif
            }
#ifdef UDF_DBG
            else {
                UDFPrint(("UDF: Fcb has invalid FCBName Buffer\n"));
                BrutePoint();
            }
#endif
            UDFReleaseObjectName(Fcb->FCBName);
            Fcb->FCBName = NULL;
        }
#ifdef UDF_DBG
        else {
            UDFPrint(("UDF: Fcb has invalid FCBName field\n"));
            BrutePoint();
        }
#endif
 
 
        // begin transaction {
        UDFTouch(&(Fcb->Vcb->FcbListResource));
        UDFAcquireResourceExclusive(&(Fcb->Vcb->FcbListResource), TRUE);
        // Remove this FCB from list of all FCB in VCB
        RemoveEntryList(&(Fcb->NextFCB));
        UDFReleaseResource(&(Fcb->Vcb->FcbListResource));
        // } end transaction
 
        if(Fcb->FCBFlags & UDF_FCB_INITIALIZED_CCB_LIST_RESOURCE)
            UDFDeleteResource(&(Fcb->CcbListResource));
 
        // Free memory
        UDFReleaseFCB(Fcb);
    } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
        BrutePoint();
    } _SEH2_END;
} // end UDFCleanUpFCB()

Referenced by UDFBlankMount(), UDFCleanUpFcbChain(), UDFCommonCreate(), and UDFCompleteMount().

UDFCleanUpFcbChain()

ULONG UDFCleanUpFcbChain	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	fi,
		IN ULONG	TreeLength,
		IN BOOLEAN	VcbAcquired
	)

Definition at line 400 of file close.cpp.

{
    PtrUDFFCB      Fcb = NULL;
    PtrUDFFCB      ParentFcb = NULL;
    PUDF_FILE_INFO ParentFI;
    UDFNTRequiredFCB* NtReqFcb;
    ULONG CleanCode;
    LONG RefCount, ComRefCount;
    BOOLEAN Delete = FALSE;
    ULONG          ret_val = 0;
 
    ValidateFileInfo(fi);
    AdPrint(("UDFCleanUpFcbChain\n"));
 
    ASSERT(TreeLength);
 
    // we can't process Tree until we can acquire Vcb
    if(!VcbAcquired)
        UDFAcquireResourceShared(&(Vcb->VCBResource),TRUE);
 
    // cleanup parent chain (if any & unused)
    while(fi) {
 
        // acquire parent
        if((ParentFI = fi->ParentFile)) {
            ASSERT(fi->Fcb);
            ParentFcb = fi->Fcb->ParentFcb;
            ASSERT(ParentFcb);
            ASSERT(ParentFcb->NTRequiredFCB);
            UDF_CHECK_PAGING_IO_RESOURCE(ParentFcb->NTRequiredFCB);
            UDFAcquireResourceExclusive(&(ParentFcb->NTRequiredFCB->MainResource),TRUE);
        } else {
            // we get to RootDir, it has no parent
            if(!VcbAcquired)
                UDFAcquireResourceShared(&(Vcb->VCBResource),TRUE);
        }
        Fcb = fi->Fcb;
        ASSERT(Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_FCB);
 
        NtReqFcb = Fcb->NTRequiredFCB;
        ASSERT(NtReqFcb->CommonFCBHeader.NodeTypeCode == UDF_NODE_TYPE_NT_REQ_FCB);
 
        // acquire current file/dir
        // we must assure that no more threads try to re-use this object
#ifdef UDF_DBG
        _SEH2_TRY {
#endif // UDF_DBG
            UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
            UDFAcquireResourceExclusive(&(NtReqFcb->MainResource),TRUE);
#ifdef UDF_DBG
        } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
            BrutePoint();
            if(ParentFI) {
                UDF_CHECK_PAGING_IO_RESOURCE(ParentFcb->NTRequiredFCB);
                UDFReleaseResource(&(ParentFcb->NTRequiredFCB->MainResource));
            } else {
                if(!VcbAcquired)
                    UDFReleaseResource(&(Vcb->VCBResource));
            }
            break;
        } _SEH2_END;
#endif // UDF_DBG
        ASSERT_REF((Fcb->ReferenceCount > fi->RefCount) || !TreeLength);
        // If we haven't pass through all files opened
        // in UDFCommonCreate before target file (TreeLength specfies
        // the number of such files) dereference them.
        // Otherwise we'll just check if the file has no references.
#ifdef UDF_DBG
        if(Fcb) {
            if(TreeLength) {
                ASSERT(Fcb->ReferenceCount);
                ASSERT(NtReqFcb->CommonRefCount);
                RefCount = UDFInterlockedDecrement((PLONG)&(Fcb->ReferenceCount));
                ComRefCount = UDFInterlockedDecrement((PLONG)&(NtReqFcb->CommonRefCount));
            }
        } else {
            BrutePoint();
        }
        if(TreeLength)
            TreeLength--;
        ASSERT(Fcb->OpenHandleCount <= Fcb->ReferenceCount);
#else
        if(TreeLength) {
            RefCount = UDFInterlockedDecrement((PLONG)&(Fcb->ReferenceCount));
            ComRefCount = UDFInterlockedDecrement((PLONG)&(NtReqFcb->CommonRefCount));
            TreeLength--;
        }
#endif
 
/*        if(Fcb && Fcb->FCBName && Fcb->FCBName->ObjectName.Buffer) {
            AdPrint(("    %ws (%x)\n",
                       Fcb->FCBName->ObjectName.Buffer,Fcb->ReferenceCount));
        } else if (Fcb) {
            AdPrint(("    ??? (%x)\n",Fcb->ReferenceCount));
        } else {
            AdPrint(("    ??? (??)\n"));
        }*/
        // ...and delete if it has gone
 
        if(!RefCount && !Fcb->OpenHandleCount) {
            // no more references... current file/dir MUST DIE!!!
            BOOLEAN AutoInherited = UDFIsAStreamDir(fi) || UDFIsAStream(fi);
 
            if(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK) {
                // do nothing
            } else
#ifndef UDF_READ_ONLY_BUILD
            if(Delete) {
/*                if(!(Fcb->FCBFlags & UDF_FCB_DIRECTORY)) {
                    // set file size to zero (for UdfInfo package)
                    // we should not do this for directories
                    UDFResizeFile__(Vcb, fi, 0);
                }*/
                UDFReferenceFile__(fi);
                ASSERT(Fcb->ReferenceCount < fi->RefCount);
                UDFFlushFile__(Vcb, fi);
                UDFUnlinkFile__(Vcb, fi, TRUE);
                UDFCloseFile__(Vcb, fi);
                ASSERT(Fcb->ReferenceCount == fi->RefCount);
                Fcb->FCBFlags |= UDF_FCB_DELETED;
                Delete = FALSE;
            } else
#endif //UDF_READ_ONLY_BUILD
            if(!(Fcb->FCBFlags & UDF_FCB_DELETED)) {
                UDFFlushFile__(Vcb, fi);
            } else {
//                BrutePoint();
            }
#ifndef UDF_READ_ONLY_BUILD
            // check if we should try to delete Parent for the next time
            if(Fcb->FCBFlags & UDF_FCB_DELETE_PARENT)
                Delete = TRUE;
#endif //UDF_READ_ONLY_BUILD
 
            // remove references to OS-specific structures
            // to let UDF_INFO release FI & Co
            fi->Fcb = NULL;
            if(!ComRefCount) {
                // CommonFcb is also completly dereferenced
                // Kill it!
                fi->Dloc->CommonFcb = NULL;
            }
 
            if((CleanCode = UDFCleanUpFile__(Vcb, fi))) {
                // Check, if we can uninitialize & deallocate CommonFcb part
                // kill some cross links
                Fcb->FileInfo = NULL;
                // release allocated resources
                if(CleanCode & UDF_FREE_DLOC) {
                    // Obviously, it is a good time & place to release
                    // CommonFcb structure
 
//                    NtReqFcb->NtReqFCBFlags &= ~UDF_NTREQ_FCB_VALID;
                    // Unitialize byte-range locks support structure
                    FsRtlUninitializeFileLock(&(NtReqFcb->FileLock));
                    // Remove resources
                    UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
                    UDFReleaseResource(&(NtReqFcb->MainResource));
                    if(NtReqFcb->CommonFCBHeader.Resource) {
                        UDFDeleteResource(&(NtReqFcb->MainResource));
                        UDFDeleteResource(&(NtReqFcb->PagingIoResource));
                    }
                    NtReqFcb->CommonFCBHeader.Resource =
                    NtReqFcb->CommonFCBHeader.PagingIoResource = NULL;
                    UDFDeassignAcl(NtReqFcb, AutoInherited);
                    UDFPrint(("UDFReleaseNtReqFCB: %x\n", NtReqFcb));
#ifdef DBG
//                    NtReqFcb->FileObject->FsContext2 = NULL;
//                    ASSERT(NtReqFcb->FileObject);
/*                    if(NtReqFcb->FileObject) {
                        ASSERT(!NtReqFcb->FileObject->FsContext2);
                        NtReqFcb->FileObject->FsContext = NULL;
                        NtReqFcb->FileObject->SectionObjectPointer = NULL;
                    }*/
#endif //DBG
                    MyFreePool__(NtReqFcb);
                    ret_val |= UDF_CLOSE_NTREQFCB_DELETED;
                } else {
                    // we usually get here when the file has some opened links
                    UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
                    UDFReleaseResource(&(NtReqFcb->MainResource));
                }
                // remove some references & free Fcb structure
                Fcb->NTRequiredFCB = NULL;
                Fcb->ParentFcb = NULL;
                UDFCleanUpFCB(Fcb);
                MyFreePool__(fi);
                ret_val |= UDF_CLOSE_FCB_DELETED;
                // get pointer to parent FCB
                fi = ParentFI;
                // free old parent's resource...
                if(fi) {
                    UDF_CHECK_PAGING_IO_RESOURCE(ParentFcb->NTRequiredFCB);
                    UDFReleaseResource(&(ParentFcb->NTRequiredFCB->MainResource));
                } else {
                    if(!VcbAcquired)
                        UDFReleaseResource(&(Vcb->VCBResource));
                }
            } else {
                // Stop cleaning up
 
                // Restore pointers
                fi->Fcb = Fcb;
                fi->Dloc->CommonFcb = NtReqFcb;
                // free all acquired resources
                UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
                UDFReleaseResource(&(NtReqFcb->MainResource));
                fi = ParentFI;
                if(fi) {
                    UDF_CHECK_PAGING_IO_RESOURCE(ParentFcb->NTRequiredFCB);
                    UDFReleaseResource(&(ParentFcb->NTRequiredFCB->MainResource));
                } else {
                    if(!VcbAcquired)
                        UDFReleaseResource(&(Vcb->VCBResource));
                }
                // If we have dereferenced all parents 'associated'
                // with input file & current file is still in use
                // then it isn't worth walking down the tree
                // 'cause in this case all the rest files are also used
                if(!TreeLength)
                    break;
//                AdPrint(("Stop on referenced File/Dir\n"));
            }
        } else {
            // we get to referenced file/dir. Stop search & release resource
            UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
            UDFReleaseResource(&(NtReqFcb->MainResource));
            if(ParentFI) {
                UDF_CHECK_PAGING_IO_RESOURCE(ParentFcb->NTRequiredFCB);
                UDFReleaseResource(&(ParentFcb->NTRequiredFCB->MainResource));
            } else {
                if(!VcbAcquired)
                    UDFReleaseResource(&(Vcb->VCBResource));
            }
            Delete = FALSE;
            if(!TreeLength)
                break;
            fi = ParentFI;
        }
    }
    if(fi) {
        Fcb = fi->Fcb;
        for(;TreeLength && fi;TreeLength--) {
            if(Fcb) {
                ParentFcb = Fcb->ParentFcb;
                ASSERT(Fcb->ReferenceCount);
                ASSERT(Fcb->NTRequiredFCB->CommonRefCount);
                ASSERT_REF(Fcb->ReferenceCount > fi->RefCount);
                UDFInterlockedDecrement((PLONG)&(Fcb->ReferenceCount));
                UDFInterlockedDecrement((PLONG)&(Fcb->NTRequiredFCB->CommonRefCount));
#ifdef UDF_DBG
            } else {
                BrutePoint();
#endif
            }
            Fcb = ParentFcb;
        }
    }
    if(!VcbAcquired)
        UDFReleaseResource(&(Vcb->VCBResource));
    return ret_val;
 
} // end UDFCleanUpFcbChain()

Referenced by UDFCloseResidual(), UDFCommonClose(), UDFCommonCreate(), and UDFRename().

UDFCleanupVCB()

VOID UDFCleanupVCB

(

IN PVCB

Vcb

)

Definition at line 1428 of file fscntrl.cpp.

{
    _SEH2_TRY {
        UDFReleaseFileIdCache(Vcb);
        UDFReleaseDlocList(Vcb);
    } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
        BrutePoint();
    } _SEH2_END;
 
    if(Vcb->ShutdownRegistered && Vcb->VCBDeviceObject) {
        IoUnregisterShutdownNotification(Vcb->VCBDeviceObject);
        Vcb->ShutdownRegistered = FALSE;
    }
 
    MyFreeMemoryAndPointer(Vcb->Partitions);
    MyFreeMemoryAndPointer(Vcb->LVid);
    MyFreeMemoryAndPointer(Vcb->Vat);
    MyFreeMemoryAndPointer(Vcb->SparingTable);
 
    if(Vcb->FSBM_Bitmap) {
        DbgFreePool(Vcb->FSBM_Bitmap);
        Vcb->FSBM_Bitmap = NULL;
    }
    if(Vcb->ZSBM_Bitmap) {
        DbgFreePool(Vcb->ZSBM_Bitmap);
        Vcb->ZSBM_Bitmap = NULL;
    }
    if(Vcb->BSBM_Bitmap) {
        DbgFreePool(Vcb->BSBM_Bitmap);
        Vcb->BSBM_Bitmap = NULL;
    }
#ifdef UDF_TRACK_ONDISK_ALLOCATION_OWNERS
    if(Vcb->FSBM_Bitmap_owners) {
        DbgFreePool(Vcb->FSBM_Bitmap_owners);
        Vcb->FSBM_Bitmap_owners = NULL;
    }
#endif //UDF_TRACK_ONDISK_ALLOCATION_OWNERS
    if(Vcb->FSBM_OldBitmap) {
        DbgFreePool(Vcb->FSBM_OldBitmap);
        Vcb->FSBM_OldBitmap = NULL;
    }
 
    MyFreeMemoryAndPointer(Vcb->Statistics);
    MyFreeMemoryAndPointer(Vcb->NTRequiredFCB);
    MyFreeMemoryAndPointer(Vcb->VolIdent.Buffer);
    MyFreeMemoryAndPointer(Vcb->TargetDevName.Buffer);
 
    if(Vcb->ZBuffer) {
        DbgFreePool(Vcb->ZBuffer);
        Vcb->ZBuffer = NULL;
    }
 
    if(Vcb->fZBuffer) {
        DbgFreePool(Vcb->fZBuffer);
        Vcb->fZBuffer = NULL;
    }
 
    MyFreeMemoryAndPointer(Vcb->OPCh);
    MyFreeMemoryAndPointer(Vcb->WParams);
    MyFreeMemoryAndPointer(Vcb->Error);
    MyFreeMemoryAndPointer(Vcb->TrackMap);
 
} // end UDFCleanupVCB()

Referenced by UDFReleaseVCB(), and UDFVerifyVolume().

UDFClose()

NTSTATUS NTAPI UDFClose	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 62 of file close.cpp.

{
    NTSTATUS            RC = STATUS_SUCCESS;
    PtrUDFIrpContext    PtrIrpContext = NULL;
    BOOLEAN             AreWeTopLevel = FALSE;
 
    AdPrint(("UDFClose: \n"));
 
    FsRtlEnterFileSystem();
    ASSERT(DeviceObject);
    ASSERT(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 (UDFIsFSDevObj(DeviceObject)) {
        // this is a close of the FSD itself
        Irp->IoStatus.Status = RC;
        Irp->IoStatus.Information = 0;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        FsRtlExitFileSystem();
        return(RC);
    }
 
    // set the top level context
    AreWeTopLevel = UDFIsIrpTopLevel(Irp);
 
    _SEH2_TRY {
 
        // get an IRP context structure and issue the request
        PtrIrpContext = UDFAllocateIrpContext(Irp, DeviceObject);
        ASSERT(PtrIrpContext);
 
        RC = UDFCommonClose(PtrIrpContext, Irp);
 
    } _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);
}

Referenced by UDFInitializeFunctionPointers().

UDFCloseAllDelayed()

VOID UDFCloseAllDelayed

(

PVCB

Vcb

)

UDFCloseAllXXXDelayedInDir()

NTSTATUS UDFCloseAllXXXDelayedInDir	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		IN BOOLEAN	System
	)

Definition at line 918 of file close.cpp.

{
    PUDF_FILE_INFO*         PassedList = NULL;
    ULONG                   PassedListSize = 0;
    PUDF_FILE_INFO*         FoundList = NULL;
    ULONG                   FoundListSize = 0;
    NTSTATUS                RC;
    ULONG                   i;
    _SEH2_VOLATILE BOOLEAN  ResAcq = FALSE;
    _SEH2_VOLATILE BOOLEAN  AcquiredVcb = FALSE;
    UDFNTRequiredFCB*       NtReqFcb;
    PUDF_FILE_INFO          CurFileInfo;
    PFE_LIST_ENTRY          CurListPtr;
    PFE_LIST_ENTRY*         ListPtrArray = NULL;
 
    _SEH2_TRY {
 
        UDFPrint(("    UDFCloseAllXXXDelayedInDir(): Acquire DelayedCloseResource\n"));
        // Acquire DelayedCloseResource
        UDFAcquireResourceExclusive(&(UDFGlobalData.DelayedCloseResource), TRUE);
        ResAcq = TRUE;
 
        UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
        AcquiredVcb = TRUE;
 
        RC = UDFBuildTreeItemsList(Vcb, FileInfo,
                System ? UDFIsLastClose : UDFIsInDelayedCloseQueue,
                &PassedList, &PassedListSize, &FoundList, &FoundListSize);
 
        if(!NT_SUCCESS(RC)) {
            UDFPrint(("    UDFBuildTreeItemsList(): error %x\n", RC));
            try_return(RC);
        }
 
        if(!FoundList || !FoundListSize) {
            try_return(RC = STATUS_SUCCESS);
        }
 
        // build array of referenced pointers
        ListPtrArray = (PFE_LIST_ENTRY*)(MyAllocatePool__(NonPagedPool, FoundListSize*sizeof(PFE_LIST_ENTRY)));
        if(!ListPtrArray) {
            UDFPrint(("    Can't alloc ListPtrArray for %x items\n", FoundListSize));
            try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
        }
 
        for(i=0;i<FoundListSize;i++) {
 
            _SEH2_TRY {
 
                CurFileInfo = FoundList[i];
                if(!CurFileInfo->ListPtr) {
                    CurFileInfo->ListPtr = (PFE_LIST_ENTRY)(MyAllocatePool__(NonPagedPool, sizeof(FE_LIST_ENTRY)));
                    if(!CurFileInfo->ListPtr) {
                        UDFPrint(("    Can't alloc ListPtrEntry for items %x\n", i));
                        try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
                    }
                    CurFileInfo->ListPtr->FileInfo = CurFileInfo;
                    CurFileInfo->ListPtr->EntryRefCount = 0;
                }
                CurFileInfo->ListPtr->EntryRefCount++;
                ListPtrArray[i] = CurFileInfo->ListPtr;
 
            } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
                BrutePoint();
            } _SEH2_END;
        }
 
        UDFReleaseResource(&(Vcb->VCBResource));
        AcquiredVcb = FALSE;
 
        if(System) {
            // Remove from system queue
            PtrUDFFCB Fcb;
            IO_STATUS_BLOCK IoStatus;
            BOOLEAN NoDelayed = (Vcb->VCBFlags & UDF_VCB_FLAGS_NO_DELAYED_CLOSE) ?
                                     TRUE : FALSE;
 
            Vcb->VCBFlags |= UDF_VCB_FLAGS_NO_DELAYED_CLOSE;
            for(i=FoundListSize;i>0;i--) {
                UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
                AcquiredVcb = TRUE;
                _SEH2_TRY {
 
                    CurListPtr = ListPtrArray[i-1];
                    CurFileInfo = CurListPtr->FileInfo;
                    if(CurFileInfo &&
                       (Fcb = CurFileInfo->Fcb)) {
                        NtReqFcb = Fcb->NTRequiredFCB;
                        ASSERT((ULONG_PTR)NtReqFcb > 0x1000);
//                            ASSERT((ULONG)(NtReqFcb->SectionObject) > 0x1000);
                        if(!(NtReqFcb->NtReqFCBFlags & UDF_NTREQ_FCB_DELETED) &&
                            (NtReqFcb->NtReqFCBFlags & UDF_NTREQ_FCB_MODIFIED)) {
                            MmPrint(("    CcFlushCache()\n"));
                            CcFlushCache(&(NtReqFcb->SectionObject), NULL, 0, &IoStatus);
                        }
                        if(NtReqFcb->SectionObject.ImageSectionObject) {
                            MmPrint(("    MmFlushImageSection()\n"));
                            MmFlushImageSection(&(NtReqFcb->SectionObject), MmFlushForWrite);
                        }
                        if(NtReqFcb->SectionObject.DataSectionObject) {
                            MmPrint(("    CcPurgeCacheSection()\n"));
                            CcPurgeCacheSection( &(NtReqFcb->SectionObject), NULL, 0, FALSE );
                        }
                    } else {
                        MmPrint(("    Skip item: deleted\n"));
                    }
                    CurListPtr->EntryRefCount--;
                    if(!CurListPtr->EntryRefCount) {
                        if(CurListPtr->FileInfo)
                            CurListPtr->FileInfo->ListPtr = NULL;
                        MyFreePool__(CurListPtr);
                    }
                } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
                    BrutePoint();
                } _SEH2_END;
                UDFReleaseResource(&(Vcb->VCBResource));
                AcquiredVcb = FALSE;
            }
            if(!NoDelayed)
                Vcb->VCBFlags &= ~UDF_VCB_FLAGS_NO_DELAYED_CLOSE;
        } else {
            // Remove from internal queue
            PtrUDFIrpContextLite NextIrpContextLite;
 
            for(i=FoundListSize;i>0;i--) {
 
                UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
                AcquiredVcb = TRUE;
 
                CurListPtr = ListPtrArray[i-1];
                CurFileInfo = CurListPtr->FileInfo;
 
                if(CurFileInfo &&
                   CurFileInfo->Fcb &&
                    (NextIrpContextLite = CurFileInfo->Fcb->IrpContextLite)) {
                    RemoveEntryList( &(NextIrpContextLite->DelayedCloseLinks) );
                    if (NextIrpContextLite->Fcb->FCBFlags & UDF_FCB_DIRECTORY) {
//                            BrutePoint();
                        UDFGlobalData.DirDelayedCloseCount--;
                    } else {
                        UDFGlobalData.DelayedCloseCount--;
                    }
                    UDFDoDelayedClose(NextIrpContextLite);
                }
                CurListPtr->EntryRefCount--;
                if(!CurListPtr->EntryRefCount) {
                    if(CurListPtr->FileInfo)
                        CurListPtr->FileInfo->ListPtr = NULL;
                    MyFreePool__(CurListPtr);
                }
                UDFReleaseResource(&(Vcb->VCBResource));
                AcquiredVcb = FALSE;
            }
        }
        RC = STATUS_SUCCESS;
 
try_exit: NOTHING;
 
    } _SEH2_FINALLY {
        // release Vcb
        if(AcquiredVcb)
            UDFReleaseResource(&(Vcb->VCBResource));
        // Release DelayedCloseResource
        if(ResAcq)
            UDFReleaseResource(&(UDFGlobalData.DelayedCloseResource));
 
        if(ListPtrArray)
            MyFreePool__(ListPtrArray);
        if(PassedList)
            MyFreePool__(PassedList);
        if(FoundList)
            MyFreePool__(FoundList);
    } _SEH2_END;
 
    return RC;
} // end UDFCloseAllXXXDelayedInDir(

UDFCloseFileInfoChain()

NTSTATUS UDFCloseFileInfoChain	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	fi,
		IN ULONG	TreeLength,
		IN BOOLEAN	VcbAcquired
	)

Definition at line 696 of file cleanup.cpp.

{
    PUDF_FILE_INFO ParentFI;
    PtrUDFFCB Fcb;
    PtrUDFFCB ParentFcb = NULL;
    NTSTATUS RC = STATUS_SUCCESS;
    NTSTATUS RC2;
 
    // we can't process Tree until we can acquire Vcb
    if(!VcbAcquired)
        UDFAcquireResourceShared(&(Vcb->VCBResource),TRUE);
 
    AdPrint(("UDFCloseFileInfoChain\n"));
    for(; TreeLength && fi; TreeLength--) {
 
        // close parent chain (if any)
        // if we started path parsing not from RootDir on Create,
        // we would never get RootDir here
        ValidateFileInfo(fi);
 
        // acquire parent
        if((ParentFI = fi->ParentFile)) {
            ParentFcb = fi->Fcb->ParentFcb;
            ASSERT(ParentFcb);
            ASSERT(ParentFcb->NTRequiredFCB);
            UDF_CHECK_PAGING_IO_RESOURCE(ParentFcb->NTRequiredFCB);
            UDFAcquireResourceExclusive(&(ParentFcb->NTRequiredFCB->MainResource),TRUE);
            ASSERT(ParentFcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_FCB);
            ASSERT(ParentFcb->NTRequiredFCB->CommonFCBHeader.NodeTypeCode == UDF_NODE_TYPE_NT_REQ_FCB);
        } else {
            AdPrint(("Acquiring VCB...\n"));
            UDFAcquireResourceShared(&(Vcb->VCBResource),TRUE);
            AdPrint(("Done\n"));
        }
        // acquire current file/dir
        // we must assure that no more threads try to reuse this object
        if((Fcb = fi->Fcb)) {
            UDF_CHECK_PAGING_IO_RESOURCE(Fcb->NTRequiredFCB);
            UDFAcquireResourceExclusive(&(Fcb->NTRequiredFCB->MainResource),TRUE);
            ASSERT_REF(Fcb->ReferenceCount >= fi->RefCount);
            if(!(Fcb->FCBFlags & UDF_FCB_DELETED) &&
                (Fcb->FCBFlags & UDF_FCB_VALID))
                UDFWriteSecurity(Vcb, Fcb, &(Fcb->NTRequiredFCB->SecurityDesc));
            RC2 = UDFCloseFile__(Vcb,fi);
            if(!NT_SUCCESS(RC2))
                RC = RC2;
            ASSERT_REF(Fcb->ReferenceCount > fi->RefCount);
            UDF_CHECK_PAGING_IO_RESOURCE(Fcb->NTRequiredFCB);
            UDFReleaseResource(&(Fcb->NTRequiredFCB->MainResource));
        } else {
            BrutePoint();
            RC2 = UDFCloseFile__(Vcb,fi);
            if(!NT_SUCCESS(RC2))
                RC = RC2;
        }
 
        if(ParentFI) {
            UDF_CHECK_PAGING_IO_RESOURCE(ParentFcb->NTRequiredFCB);
            UDFReleaseResource(&(ParentFcb->NTRequiredFCB->MainResource));
        } else {
            UDFReleaseResource(&(Vcb->VCBResource));
        }
        fi = ParentFI;
    }
 
    if(!VcbAcquired)
        UDFReleaseResource(&(Vcb->VCBResource));
 
    return RC;
 
} // end UDFCloseFileInfoChain()

Referenced by UDFCommonCleanup(), and UDFCommonCreate().

UDFCloseResidual()

VOID UDFCloseResidual

(

IN PVCB

Vcb

)

Definition at line 1349 of file fscntrl.cpp.

{
    //  Deinitialize Non-alloc file
    if(Vcb->VCBOpenCount)
        UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
    UDFPrint(("UDFCloseResidual: NonAllocFileInfo %x\n", Vcb->NonAllocFileInfo));
    if(Vcb->NonAllocFileInfo) {
        UDFCloseFile__(Vcb,Vcb->NonAllocFileInfo);
        UDFCleanUpFile__(Vcb, Vcb->NonAllocFileInfo);
        MyFreePool__(Vcb->NonAllocFileInfo);
        Vcb->NonAllocFileInfo = NULL;
    }
    //  Deinitialize Unique ID Mapping
    UDFPrint(("UDFCloseResidual: NonAllocFileInfo %x\n", Vcb->NonAllocFileInfo));
    if(Vcb->UniqueIDMapFileInfo) {
        UDFCloseFile__(Vcb,Vcb->UniqueIDMapFileInfo);
        UDFCleanUpFile__(Vcb, Vcb->UniqueIDMapFileInfo);
        MyFreePool__(Vcb->UniqueIDMapFileInfo);
        Vcb->UniqueIDMapFileInfo = NULL;
    }
    //  Deinitialize VAT file
    UDFPrint(("UDFCloseResidual: VatFileInfo %x\n", Vcb->VatFileInfo));
    if(Vcb->VatFileInfo) {
        UDFCloseFile__(Vcb,Vcb->VatFileInfo);
        UDFCleanUpFile__(Vcb, Vcb->VatFileInfo);
        MyFreePool__(Vcb->VatFileInfo);
        Vcb->VatFileInfo = NULL;
    }
    //  System StreamDir
    UDFPrint(("UDFCloseResidual: SysSDirFileInfo %x\n", Vcb->SysSDirFileInfo));
    if(Vcb->SysSDirFileInfo) {
        UDFCloseFile__(Vcb, Vcb->SysSDirFileInfo);
        UDFCleanUpFile__(Vcb, Vcb->SysSDirFileInfo);
        MyFreePool__(Vcb->SysSDirFileInfo);
        Vcb->SysSDirFileInfo = NULL;
    }
/*    //  Deinitialize root dir fcb
    if(Vcb->RootDirFCB) {
        UDFCloseFile__(Vcb,Vcb->RootDirFCB->FileInfo);
        UDFCleanUpFile__(Vcb, Vcb->RootDirFCB->FileInfo);
        MyFreePool__(Vcb->RootDirFCB->FileInfo);
        UDFCleanUpFCB(Vcb->RootDirFCB);
        //  Remove root FCB reference in vcb
        if(Vcb->VCBOpenCount) Vcb->VCBOpenCount--;
    }
 
    // Deinitialize Non-alloc file
    if(Vcb->VCBOpenCount) Vcb->VCBOpenCount--;
    if(Vcb->NonAllocFileInfo) {
        UDFCloseFile__(Vcb,Vcb->NonAllocFileInfo);
        // We must release VCB here !!!!
//        UDFCleanUpFcbChain(Vcb, Vcb->NonAllocFileInfo, 1);
        Vcb->NonAllocFileInfo = NULL;
    }
    // Deinitialize VAT file
    if(Vcb->VatFileInfo) {
        UDFCloseFile__(Vcb,Vcb->VatFileInfo);
        // We must release VCB here !!!!
//        UDFCleanUpFcbChain(Vcb, Vcb->VatFileInfo, 1);
        Vcb->VatFileInfo = NULL;
    }*/
 
    // Deinitialize root dir fcb
    UDFPrint(("UDFCloseResidual: RootDirFCB %x\n", Vcb->RootDirFCB));
    if(Vcb->RootDirFCB) {
        UDFCloseFile__(Vcb,Vcb->RootDirFCB->FileInfo);
        if(Vcb->RootDirFCB->OpenHandleCount)
            Vcb->RootDirFCB->OpenHandleCount--;
        UDFCleanUpFcbChain(Vcb, Vcb->RootDirFCB->FileInfo, 1, TRUE);
        // Remove root FCB reference in vcb
        if(Vcb->VCBOpenCount)
            UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
        Vcb->RootDirFCB = NULL;
    }
} // end UDFCloseResidual()

Referenced by UDFDismountVcb(), and UDFMountVolume().

UDFCommonCleanup()

NTSTATUS UDFCommonCleanup	(	PtrUDFIrpContext	PtrIrpContext,
		PIRP	Irp
	)

Definition at line 126 of file cleanup.cpp.

{
    IO_STATUS_BLOCK         IoStatus;
    NTSTATUS                RC = STATUS_SUCCESS;
    NTSTATUS                RC2;
    PIO_STACK_LOCATION      IrpSp = NULL;
    PFILE_OBJECT            FileObject = NULL;
    PtrUDFFCB               Fcb = NULL;
    PtrUDFCCB               Ccb = NULL;
    PVCB                    Vcb = NULL;
    PtrUDFNTRequiredFCB     NtReqFcb = NULL;
    ULONG                   lc = 0;
    BOOLEAN                 AcquiredVcb = FALSE;
    BOOLEAN                 AcquiredFCB = FALSE;
    BOOLEAN                 AcquiredParentFCB = FALSE;
 
//    BOOLEAN                 CompleteIrp = TRUE;
//    BOOLEAN                 PostRequest = FALSE;
    BOOLEAN                 ChangeTime = FALSE;
#ifdef UDF_DBG
    BOOLEAN                 CanWait = FALSE;
#endif // UDF_DBG
    BOOLEAN                 ForcedCleanUp = FALSE;
 
    PUDF_FILE_INFO          NextFileInfo = NULL;
#ifdef UDF_DBG
    UNICODE_STRING          CurName;
    PDIR_INDEX_HDR          DirNdx;
#endif // UDF_DBG
//    PUDF_DATALOC_INFO       Dloc;
 
    TmPrint(("UDFCommonCleanup\n"));
 
//    BrutePoint();
 
    _SEH2_TRY {
        // First, get a pointer to the current I/O stack location
        IrpSp = IoGetCurrentIrpStackLocation(Irp);
        if(!IrpSp) try_return(RC = STATUS_INVALID_PARAMETER);
 
        FileObject = IrpSp->FileObject;
 
        // Get the FCB and CCB pointers
        Ccb = (PtrUDFCCB)(FileObject->FsContext2);
        ASSERT(Ccb);
        Fcb = Ccb->Fcb;
        ASSERT(Fcb);
 
        Vcb = (PVCB)(PtrIrpContext->TargetDeviceObject->DeviceExtension);
        ASSERT(Vcb);
        ASSERT(Vcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB);
//        Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
#ifdef UDF_DBG
        CanWait = (PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_CAN_BLOCK) ? TRUE : FALSE;
        AdPrint(("   %s\n", CanWait ? "Wt" : "nw"));
        ASSERT(CanWait);
#endif // UDF_DBG
        UDFAcquireResourceShared(&(Vcb->VCBResource), TRUE);
        AcquiredVcb = TRUE;
        // Steps we shall take at this point are:
        // (a) Acquire the file (FCB) exclusively
        // (b) Flush file data to disk
        // (c) Talk to the FSRTL package (if we use it) about pending oplocks.
        // (d) Notify the FSRTL package for use with pending notification IRPs
        // (e) Unlock byte-range locks (if any were acquired by process)
        // (f) Update time stamp values (e.g. fast-IO had been performed)
        // (g) Inform the Cache Manager to uninitialize Cache Maps ...
        // and other similar stuff.
        //  BrutePoint();
        NtReqFcb = Fcb->NTRequiredFCB;
 
        if (Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB) {
            AdPrint(("Cleaning up Volume\n"));
            AdPrint(("UDF: OpenHandleCount: %x\n",Fcb->OpenHandleCount));
 
            UDFInterlockedDecrement((PLONG)&(Fcb->OpenHandleCount));
            UDFInterlockedDecrement((PLONG)&(Vcb->VCBHandleCount));
            if(FileObject->Flags & FO_CACHE_SUPPORTED) {
                // we've cached close
                UDFInterlockedDecrement((PLONG)&(Fcb->CachedOpenHandleCount));
            }
            ASSERT(Fcb->OpenHandleCount <= (Fcb->ReferenceCount-1));
 
            //  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).
            if( FileObject->WriteAccess &&
               (FileObject->Flags & FO_FILE_MODIFIED)) {
 
                Vcb->Vpb->RealDevice->Flags |= DO_VERIFY_VOLUME;
            }
            // User may decide to close locked volume without call to unlock proc
            // So, handle this situation properly & unlock it now...
            if (FileObject == Vcb->VolumeLockFileObject) {
                Vcb->VolumeLockFileObject = NULL;
                Vcb->VolumeLockPID = -1;
                Vcb->VCBFlags &= ~UDF_VCB_FLAGS_VOLUME_LOCKED;
                Vcb->Vpb->Flags &= ~VPB_LOCKED;
                UDFNotifyVolumeEvent(FileObject, FSRTL_VOLUME_UNLOCK);
            }
 
            MmPrint(("    CcUninitializeCacheMap()\n"));
            CcUninitializeCacheMap(FileObject, NULL, NULL);
            // reset device
            if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED) &&
                (Vcb->VCBFlags & UDF_VCB_FLAGS_OUR_DEVICE_DRIVER)) {
                // this call doesn't modify data buffer
                // it just requires its presence
                UDFResetDeviceDriver(Vcb, Vcb->TargetDeviceObject, TRUE);
            }
            //  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, &(NtReqFcb->FCBShareAccess) );
 
            try_return(RC = STATUS_SUCCESS);
        }
//        BrutePoint();
#ifdef UDF_DBG
        DirNdx = UDFGetDirIndexByFileInfo(Fcb->FileInfo);
        if(DirNdx) {
            CurName.Buffer = UDFDirIndex(DirNdx, Fcb->FileInfo->Index)->FName.Buffer;
            if(CurName.Buffer) {
                AdPrint(("Cleaning up file: %ws %8.8x\n", CurName.Buffer, FileObject));
            } else {
                AdPrint(("Cleaning up file: ??? \n"));
            }
        }
#endif //UDF_DBG
        AdPrint(("UDF: OpenHandleCount: %x\n",Fcb->OpenHandleCount));
        // Acquire parent object
        if(Fcb->FileInfo->ParentFile) {
            UDF_CHECK_PAGING_IO_RESOURCE(Fcb->FileInfo->ParentFile->Fcb->NTRequiredFCB);
            UDFAcquireResourceExclusive(&(Fcb->FileInfo->ParentFile->Fcb->NTRequiredFCB->MainResource),TRUE);
        } else {
            UDFAcquireResourceShared(&(Vcb->VCBResource),TRUE);
        }
        AcquiredParentFCB = TRUE;
        // Acquire current object
        UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
        UDFAcquireResourceExclusive(&(NtReqFcb->MainResource),TRUE);
        AcquiredFCB = TRUE;
        // dereference object
        UDFInterlockedDecrement((PLONG)&(Fcb->OpenHandleCount));
        UDFInterlockedDecrement((PLONG)&(Vcb->VCBHandleCount));
        if(FileObject->Flags & FO_CACHE_SUPPORTED) {
            // we've cached close
            UDFInterlockedDecrement((PLONG)&(Fcb->CachedOpenHandleCount));
        }
        ASSERT(Fcb->OpenHandleCount <= (Fcb->ReferenceCount-1));
        // check if Ccb being cleaned up has DeleteOnClose flag set
#ifndef UDF_READ_ONLY_BUILD
        if(Ccb->CCBFlags & UDF_CCB_DELETE_ON_CLOSE) {
            AdPrint(("    DeleteOnClose\n"));
            // Ok, now we'll become 'delete on close'...
            ASSERT(!(Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY));
            Fcb->FCBFlags |= UDF_FCB_DELETE_ON_CLOSE;
            FileObject->DeletePending = TRUE;
            //  Report this to the dir notify package for a directory.
            if(Fcb->FCBFlags & UDF_FCB_DIRECTORY) {
                FsRtlNotifyFullChangeDirectory( Vcb->NotifyIRPMutex, &(Vcb->NextNotifyIRP),
                                                (PVOID)Ccb, NULL, FALSE, FALSE,
                                                0, NULL, NULL, NULL );
            }
        }
#endif //UDF_READ_ONLY_BUILD
 
        if(!(Fcb->FCBFlags & UDF_FCB_DIRECTORY)) {
            //  Unlock all outstanding file locks.
            FsRtlFastUnlockAll(&(NtReqFcb->FileLock),
                               FileObject,
                               IoGetRequestorProcess(Irp),
                               NULL);
        }
        // get Link count
        lc = UDFGetFileLinkCount(Fcb->FileInfo);
 
#ifndef UDF_READ_ONLY_BUILD
        if( (Fcb->FCBFlags & UDF_FCB_DELETE_ON_CLOSE) &&
           !(Fcb->OpenHandleCount)) {
            // This can be useful for Streams, those were brutally deleted
            // (together with parent object)
            ASSERT(!(Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY));
            FileObject->DeletePending = TRUE;
 
            // we should mark all streams of the file being deleted
            // for deletion too, if there are no more Links to
            // main data stream
            if((lc <= 1) &&
               !UDFIsSDirDeleted(Fcb->FileInfo->Dloc->SDirInfo)) {
                RC = UDFMarkStreamsForDeletion(Vcb, Fcb, TRUE); // Delete
            }
            // we can release these resources 'cause UDF_FCB_DELETE_ON_CLOSE
            // flag is already set & the file can't be opened
            UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
            UDFReleaseResource(&(NtReqFcb->MainResource));
            AcquiredFCB = FALSE;
            if(Fcb->FileInfo->ParentFile) {
                UDF_CHECK_PAGING_IO_RESOURCE(Fcb->ParentFcb->NTRequiredFCB);
                UDFReleaseResource(&(Fcb->ParentFcb->NTRequiredFCB->MainResource));
            } else {
                UDFReleaseResource(&(Vcb->VCBResource));
            }
            AcquiredParentFCB = FALSE;
            UDFReleaseResource(&(Vcb->VCBResource));
            AcquiredVcb = FALSE;
 
            // Make system to issue last Close request
            // for our Target ...
            UDFRemoveFromSystemDelayedQueue(Fcb);
 
#ifdef UDF_DELAYED_CLOSE
            // remove file from our DelayedClose queue
            UDFRemoveFromDelayedQueue(Fcb);
            ASSERT(!Fcb->IrpContextLite);
#endif //UDF_DELAYED_CLOSE
 
            UDFAcquireResourceShared(&(Vcb->VCBResource), TRUE);
            AcquiredVcb = TRUE;
            if(Fcb->FileInfo->ParentFile) {
                UDF_CHECK_PAGING_IO_RESOURCE(Fcb->ParentFcb->NTRequiredFCB);
                UDFAcquireResourceExclusive(&(Fcb->ParentFcb->NTRequiredFCB->MainResource),TRUE);
            } else {
                UDFAcquireResourceShared(&(Vcb->VCBResource),TRUE);
            }
            AcquiredParentFCB = TRUE;
            UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
            UDFAcquireResourceExclusive(&(NtReqFcb->MainResource),TRUE);
            AcquiredFCB = TRUE;
 
            // we should set file sizes to zero if there are no more
            // links to this file
            if(lc <= 1) {
                // Synchronize here with paging IO
                UDFAcquireResourceExclusive(&(NtReqFcb->PagingIoResource),TRUE);
                // set file size to zero (for system cache manager)
//                NtReqFcb->CommonFCBHeader.ValidDataLength.QuadPart =
                NtReqFcb->CommonFCBHeader.FileSize.QuadPart =
                NtReqFcb->CommonFCBHeader.ValidDataLength.QuadPart = 0;
                CcSetFileSizes(FileObject, (PCC_FILE_SIZES)&(NtReqFcb->CommonFCBHeader.AllocationSize));
 
                UDFReleaseResource(&(NtReqFcb->PagingIoResource));
            }
        }
#endif //UDF_READ_ONLY_BUILD
 
#ifdef UDF_DELAYED_CLOSE
        if ((Fcb->ReferenceCount == 1) &&
         /*(Fcb->NodeIdentifier.NodeType != UDF_NODE_TYPE_VCB) &&*/ // see above
            (!(Fcb->FCBFlags & UDF_FCB_DELETE_ON_CLOSE)) ) {
            Fcb->FCBFlags |= UDF_FCB_DELAY_CLOSE;
        }
#endif //UDF_DELAYED_CLOSE
 
        NextFileInfo = Fcb->FileInfo;
 
#ifndef UDF_READ_ONLY_BUILD
        // do we need to delete it now ?
        if( (Fcb->FCBFlags & UDF_FCB_DELETE_ON_CLOSE) &&
           !(Fcb->OpenHandleCount)) {
 
            // can we do it ?
            if(Fcb->FCBFlags & UDF_FCB_DIRECTORY) {
                ASSERT(!(Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY));
                if(!UDFIsDirEmpty__(NextFileInfo)) {
                    // forget about it
                    Fcb->FCBFlags &= ~UDF_FCB_DELETE_ON_CLOSE;
                    goto DiscardDelete;
                }
            } else
            if (lc <= 1) {
                // Synchronize here with paging IO
                BOOLEAN AcquiredPagingIo;
                AcquiredPagingIo = UDFAcquireResourceExclusiveWithCheck(&(NtReqFcb->PagingIoResource));
                // set file size to zero (for UdfInfo package)
                // we should not do this for directories and linked files
                UDFResizeFile__(Vcb, NextFileInfo, 0);
                if(AcquiredPagingIo) {
                    UDFReleaseResource(&(NtReqFcb->PagingIoResource));
                }
            }
            // mark parent object for deletion if requested
            if((Fcb->FCBFlags & UDF_FCB_DELETE_PARENT) &&
                Fcb->ParentFcb) {
                ASSERT(!(Fcb->ParentFcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY));
                Fcb->ParentFcb->FCBFlags |= UDF_FCB_DELETE_ON_CLOSE;
            }
            // flush file. It is required by UDFUnlinkFile__()
            RC = UDFFlushFile__(Vcb, NextFileInfo);
            if(!NT_SUCCESS(RC)) {
                AdPrint(("Error flushing file !!!\n"));
            }
            // try to unlink
            if((RC = UDFUnlinkFile__(Vcb, NextFileInfo, TRUE)) == STATUS_CANNOT_DELETE) {
                // If we can't delete file with Streams due to references,
                // mark SDir & Streams
                // for Deletion. We shall also set DELETE_PARENT flag to
                // force Deletion of the current file later... when curently
                // opened Streams would be cleaned up.
 
                // WARNING! We should keep SDir & Streams if there is a
                // link to this file
                if(NextFileInfo->Dloc &&
                   NextFileInfo->Dloc->SDirInfo &&
                   NextFileInfo->Dloc->SDirInfo->Fcb) {
 
                    BrutePoint();
                    if(!UDFIsSDirDeleted(NextFileInfo->Dloc->SDirInfo)) {
//                        RC = UDFMarkStreamsForDeletion(Vcb, Fcb, TRUE); // Delete
//#ifdef UDF_ALLOW_PRETEND_DELETED
                        UDFPretendFileDeleted__(Vcb, Fcb->FileInfo);
//#endif //UDF_ALLOW_PRETEND_DELETED
                    }
                    goto NotifyDelete;
 
                } else {
                    // Getting here means that we can't delete file because of
                    // References/PemissionsDenied/Smth.Else,
                    // but not Linked+OpenedStream
                    BrutePoint();
//                    RC = STATUS_SUCCESS;
                    goto DiscardDelete_1;
                }
            } else {
DiscardDelete_1:
                // We have got an ugly ERROR, or
                // file is deleted, so forget about it
                ASSERT(!(Fcb->FCBFlags & UDF_FCB_ROOT_DIRECTORY));
                ForcedCleanUp = TRUE;
                if(NT_SUCCESS(RC))
                    Fcb->FCBFlags &= ~UDF_FCB_DELETE_ON_CLOSE;
                Fcb->FCBFlags |= UDF_FCB_DELETED;
                RC = STATUS_SUCCESS;
            }
NotifyDelete:
            // We should prevent SetEOF operations on completly
            // deleted data streams
            if(lc < 1) {
                NtReqFcb->NtReqFCBFlags |= UDF_NTREQ_FCB_DELETED;
            }
            // Report that we have removed an entry.
            if(UDFIsAStream(NextFileInfo)) {
                UDFNotifyFullReportChange( Vcb, NextFileInfo,
                                       FILE_NOTIFY_CHANGE_STREAM_NAME,
                                       FILE_ACTION_REMOVED_STREAM);
            } else {
                UDFNotifyFullReportChange( Vcb, NextFileInfo,
                                       UDFIsADirectory(NextFileInfo) ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME,
                                       FILE_ACTION_REMOVED);
            }
        } else
        if(Fcb->FCBFlags & UDF_FCB_DELETE_ON_CLOSE) {
DiscardDelete:
            UDFNotifyFullReportChange( Vcb, NextFileInfo,
                                     ((Ccb->CCBFlags & UDF_CCB_ACCESS_TIME_SET) ? FILE_NOTIFY_CHANGE_LAST_ACCESS : 0) |
                                     ((Ccb->CCBFlags & UDF_CCB_WRITE_TIME_SET) ? (FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_LAST_WRITE) : 0) |
                                     0,
                                     UDFIsAStream(NextFileInfo) ? FILE_ACTION_MODIFIED_STREAM : FILE_ACTION_MODIFIED);
        }
#endif //UDF_READ_ONLY_BUILD
 
        if(Fcb->FCBFlags & UDF_FCB_DIRECTORY) {
            //  Report to the dir notify package for a directory.
            FsRtlNotifyCleanup( Vcb->NotifyIRPMutex, &(Vcb->NextNotifyIRP), (PVOID)Ccb );
        }
 
        // we can't purge Cache when more than one link exists
        if(lc > 1) {
            ForcedCleanUp = FALSE;
        }
 
        if ( (FileObject->Flags & FO_CACHE_SUPPORTED) &&
             (NtReqFcb->SectionObject.DataSectionObject) ) {
            BOOLEAN LastNonCached = (!Fcb->CachedOpenHandleCount &&
                                      Fcb->OpenHandleCount);
            // 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.
            // We shall not flush deleted files
            RC = STATUS_SUCCESS;
            if(  LastNonCached
                      ||
                (!Fcb->OpenHandleCount &&
                 !ForcedCleanUp) ) {
 
#ifndef UDF_READ_ONLY_BUILD
                LONGLONG OldFileSize, NewFileSize;
 
                if( (OldFileSize = NtReqFcb->CommonFCBHeader.ValidDataLength.QuadPart) <
                    (NewFileSize = NtReqFcb->CommonFCBHeader.FileSize.QuadPart)) {
/*                    UDFZeroDataEx(NtReqFcb,
                                  OldFileSize,
                                  NewFileSize - OldFileSize,
                                  TRUE, Vcb, FileObject);*/
 
                    NtReqFcb->CommonFCBHeader.ValidDataLength.QuadPart = NewFileSize;
                }
#endif //UDF_READ_ONLY_BUILD
                MmPrint(("    CcFlushCache()\n"));
                CcFlushCache( &(NtReqFcb->SectionObject), NULL, 0, &IoStatus );
                if(!NT_SUCCESS(IoStatus.Status)) {
                    MmPrint(("    CcFlushCache() error: %x\n", IoStatus.Status));
                    RC = IoStatus.Status;
                }
            }
            // If file is deleted or it is last cached open, but there are
            // some non-cached handles we should purge cache section
            if(ForcedCleanUp || LastNonCached) {
                if(NtReqFcb->SectionObject.DataSectionObject) {
                    MmPrint(("    CcPurgeCacheSection()\n"));
                    CcPurgeCacheSection( &(NtReqFcb->SectionObject), NULL, 0, FALSE );
                }
/*                MmPrint(("    CcPurgeCacheSection()\n"));
                CcPurgeCacheSection( &(NtReqFcb->SectionObject), NULL, 0, FALSE );*/
            }
            // we needn't Flush here. It will be done in UDFCloseFileInfoChain()
        }
 
#ifndef UDF_READ_ONLY_BUILD
        // Update FileTimes & Attrs
        if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY) &&
           !(Fcb->FCBFlags & (UDF_FCB_DELETE_ON_CLOSE |
                              UDF_FCB_DELETED /*|
                              UDF_FCB_DIRECTORY |
                              UDF_FCB_READ_ONLY*/)) &&
           !UDFIsAStreamDir(NextFileInfo)) {
            LONGLONG NtTime;
            LONGLONG ASize;
            KeQuerySystemTime((PLARGE_INTEGER)&NtTime);
            // Check if we should set ARCHIVE bit & LastWriteTime
            if(FileObject->Flags & FO_FILE_MODIFIED) {
                ULONG Attr;
                PDIR_INDEX_ITEM DirNdx;
                DirNdx = UDFDirIndex(UDFGetDirIndexByFileInfo(NextFileInfo), NextFileInfo->Index);
                ASSERT(DirNdx);
                // Archive bit
                if(!(Ccb->CCBFlags & UDF_CCB_ATTRIBUTES_SET) &&
                    (Vcb->CompatFlags & UDF_VCB_IC_UPDATE_ARCH_BIT)) {
                    Attr = UDFAttributesToNT(DirNdx, NextFileInfo->Dloc->FileEntry);
                    if(!(Attr & FILE_ATTRIBUTE_ARCHIVE))
                        UDFAttributesToUDF(DirNdx, NextFileInfo->Dloc->FileEntry, Attr | FILE_ATTRIBUTE_ARCHIVE);
                }
                // WriteTime
                if(!(Ccb->CCBFlags & UDF_CCB_WRITE_TIME_SET) &&
                    (Vcb->CompatFlags & UDF_VCB_IC_UPDATE_MODIFY_TIME)) {
                    UDFSetFileXTime(NextFileInfo, NULL, &NtTime, NULL, &NtTime);
                    NtReqFcb->LastWriteTime.QuadPart =
                    NtReqFcb->LastAccessTime.QuadPart = NtTime;
                    ChangeTime = TRUE;
                }
            }
            if(!(Fcb->FCBFlags & UDF_FCB_DIRECTORY)) {
                // Update sizes in DirIndex
                if(!Fcb->OpenHandleCount) {
                    ASize = UDFGetFileAllocationSize(Vcb, NextFileInfo);
//                        NtReqFcb->CommonFCBHeader.AllocationSize.QuadPart;
                    UDFSetFileSizeInDirNdx(Vcb, NextFileInfo, &ASize);
                } else
                if(FileObject->Flags & FO_FILE_SIZE_CHANGED) {
                    ASize = //UDFGetFileAllocationSize(Vcb, NextFileInfo);
                        NtReqFcb->CommonFCBHeader.AllocationSize.QuadPart;
                    UDFSetFileSizeInDirNdx(Vcb, NextFileInfo, &ASize);
                }
            }
            // AccessTime
            if((FileObject->Flags & FO_FILE_FAST_IO_READ) &&
               !(Ccb->CCBFlags & UDF_CCB_ACCESS_TIME_SET) &&
                (Vcb->CompatFlags & UDF_VCB_IC_UPDATE_ACCESS_TIME)) {
                UDFSetFileXTime(NextFileInfo, NULL, &NtTime, NULL, NULL);
                NtReqFcb->LastAccessTime.QuadPart = NtTime;
//                ChangeTime = TRUE;
            }
            // ChangeTime (AttrTime)
            if(!(Ccb->CCBFlags & UDF_CCB_MODIFY_TIME_SET) &&
                (Vcb->CompatFlags & UDF_VCB_IC_UPDATE_ATTR_TIME) &&
                (ChangeTime || (Ccb->CCBFlags & (UDF_CCB_ATTRIBUTES_SET |
                                                 UDF_CCB_CREATE_TIME_SET |
                                                 UDF_CCB_ACCESS_TIME_SET |
                                                 UDF_CCB_WRITE_TIME_SET))) ) {
                UDFSetFileXTime(NextFileInfo, NULL, NULL, &NtTime, NULL);
                NtReqFcb->ChangeTime.QuadPart = NtTime;
            }
        }
#endif //UDF_READ_ONLY_BUILD
 
        if(!(Fcb->FCBFlags & UDF_FCB_DIRECTORY) &&
            ForcedCleanUp) {
            // flush system cache
            MmPrint(("    CcUninitializeCacheMap()\n"));
            CcUninitializeCacheMap(FileObject, &(UDFGlobalData.UDFLargeZero), NULL);
        } else {
            MmPrint(("    CcUninitializeCacheMap()\n"));
            CcUninitializeCacheMap(FileObject, NULL, NULL);
        }
 
        // release resources now.
        // they'll be acquired in UDFCloseFileInfoChain()
        UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
        UDFReleaseResource(&(NtReqFcb->MainResource));
        AcquiredFCB = FALSE;
 
        if(Fcb->FileInfo->ParentFile) {
            UDF_CHECK_PAGING_IO_RESOURCE(Fcb->FileInfo->ParentFile->Fcb->NTRequiredFCB);
            UDFReleaseResource(&(Fcb->FileInfo->ParentFile->Fcb->NTRequiredFCB->MainResource));
        } else {
            UDFReleaseResource(&(Vcb->VCBResource));
        }
        AcquiredParentFCB = FALSE;
        // close the chain
        ASSERT(AcquiredVcb);
        RC2 = UDFCloseFileInfoChain(Vcb, NextFileInfo, Ccb->TreeLength, TRUE);
        if(NT_SUCCESS(RC))
            RC = RC2;
 
        Ccb->CCBFlags |= UDF_CCB_CLEANED;
 
        //  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, &(NtReqFcb->FCBShareAccess) );
 
        NtReqFcb->CommonFCBHeader.IsFastIoPossible = UDFIsFastIoPossible(Fcb);
 
        FileObject->Flags |= FO_CLEANUP_COMPLETE;
 
try_exit: NOTHING;
 
    } _SEH2_FINALLY {
 
        if(AcquiredFCB) {
            UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
            UDFReleaseResource(&(NtReqFcb->MainResource));
        }
 
        if(AcquiredParentFCB) {
            if(Fcb->FileInfo->ParentFile) {
                UDF_CHECK_PAGING_IO_RESOURCE(Fcb->FileInfo->ParentFile->Fcb->NTRequiredFCB);
                UDFReleaseResource(&(Fcb->FileInfo->ParentFile->Fcb->NTRequiredFCB->MainResource));
            } else {
                UDFReleaseResource(&(Vcb->VCBResource));
            }
        }
 
        if(AcquiredVcb) {
            UDFReleaseResource(&(Vcb->VCBResource));
            AcquiredVcb = FALSE;
        }
 
        if (!_SEH2_AbnormalTermination()) {
            // complete the IRP
            Irp->IoStatus.Status = RC;
            Irp->IoStatus.Information = 0;
            IoCompleteRequest(Irp, IO_DISK_INCREMENT);
            // Free up the Irp Context
            UDFReleaseIrpContext(PtrIrpContext);
        }
 
    } _SEH2_END; // end of "__finally" processing
    return(RC);
} // end UDFCommonCleanup()

Referenced by UDFCleanup(), and UDFCommonDispatch().

UDFCommonClose()

NTSTATUS UDFCommonClose	(	PtrUDFIrpContext	PtrIrpContext,
		PIRP	Irp
	)

Definition at line 137 of file close.cpp.

{
    NTSTATUS                RC = STATUS_SUCCESS;
    PIO_STACK_LOCATION      IrpSp = NULL;
    PFILE_OBJECT            FileObject = NULL;
    PtrUDFFCB               Fcb = NULL;
    PtrUDFCCB               Ccb = NULL;
    PVCB                    Vcb = NULL;
//    PERESOURCE              PtrResourceAcquired = NULL;
    BOOLEAN                 AcquiredVcb = FALSE;
    BOOLEAN                 AcquiredGD = FALSE;
    PUDF_FILE_INFO          fi;
    ULONG                   i = 0;
//    ULONG                   clean_stat = 0;
 
//    BOOLEAN                 CompleteIrp = TRUE;
    BOOLEAN                 PostRequest = FALSE;
 
#ifdef UDF_DBG
    UNICODE_STRING          CurName;
    PDIR_INDEX_HDR          DirNdx;
#endif
 
    AdPrint(("UDFCommonClose: \n"));
 
    _SEH2_TRY {
        if (Irp) {
 
            // If this is the first (IOManager) request
            // 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);
            if(Ccb->CCBFlags & UDF_CCB_READ_ONLY) {
                PtrIrpContext->IrpContextFlags |= UDF_IRP_CONTEXT_READ_ONLY;
            }
            Fcb = Ccb->Fcb;
        } else {
            // If this is a queued call (for our dispatch)
            // Get saved Fcb address
            Fcb = PtrIrpContext->Fcb;
            i = PtrIrpContext->TreeLength;
        }
 
        ASSERT(Fcb);
        Vcb = (PVCB)(PtrIrpContext->TargetDeviceObject->DeviceExtension);
        ASSERT(Vcb);
        ASSERT(Vcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB);
//        Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
 
        // Steps we shall take at this point are:
        // (a) Acquire the VCB shared
        // (b) Acquire the FCB's CCB list exclusively
        // (c) Delete the CCB structure (free memory)
        // (d) If this is the last close, release the FCB structure
        //       (unless we keep these around for "delayed close" functionality.
        // Note that it is often the case that the close dispatch entry point is invoked
        // in the most inconvenient of situations (when it is not possible, for example,
        // to safely acquire certain required resources without deadlocking or waiting).
        // Therefore, be extremely careful in implementing this close dispatch entry point.
        // Also note that we do not have the option of returning a failure code from the
        // close dispatch entry point; the system expects that the close will always succeed.
 
        UDFAcquireResourceShared(&(Vcb->VCBResource), TRUE);
        AcquiredVcb = TRUE;
 
        // Is this is the first (IOManager) request ?
        if (Irp) {
            PtrIrpContext->TreeLength =
            i = Ccb->TreeLength;
            // remember the number of incomplete Close requests
            InterlockedIncrement((PLONG)&(Fcb->CcbCount));
            // we can release CCB in any case
            UDFCleanUpCCB(Ccb);
            FileObject->FsContext2 = NULL;
#ifdef DBG
/*        } else {
            ASSERT(Fcb->NTRequiredFCB);
            if(Fcb->NTRequiredFCB) {
                ASSERT(Fcb->NTRequiredFCB->FileObject);
                if(Fcb->NTRequiredFCB->FileObject) {
                    ASSERT(!Fcb->NTRequiredFCB->FileObject->FsContext2);
                }
            }*/
#endif //DBG
        }
 
#ifdef UDF_DELAYED_CLOSE
        // check if this is the last Close (no more Handles)
        // and try to Delay it....
        if((Fcb->FCBFlags & UDF_FCB_DELAY_CLOSE) &&
           (Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED) &&
          !(Vcb->VCBFlags & UDF_VCB_FLAGS_NO_DELAYED_CLOSE) &&
          !(Fcb->OpenHandleCount)) {
            UDFReleaseResource(&(Vcb->VCBResource));
            AcquiredVcb = FALSE;
            if((RC = UDFQueueDelayedClose(PtrIrpContext,Fcb)) == STATUS_SUCCESS)
                try_return(RC = STATUS_SUCCESS);
            // do standard Close if we can't Delay this opeartion
            AdPrint(("   Cant queue Close Irp, status=%x\n", RC));
        }
#endif //UDF_DELAYED_CLOSE
 
        if(Irp) {
            // We should post actual procesing if this is a recursive call
            if((PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_NOT_TOP_LEVEL) ||
               (Fcb->NTRequiredFCB->AcqFlushCount)) {
                AdPrint(("   post NOT_TOP_LEVEL Irp\n"));
                PostRequest = TRUE;
                try_return(RC = STATUS_SUCCESS);
            }
        }
 
        // Close request is near completion, Vcb is acquired.
        // Now we can safely decrease CcbCount, because no Rename
        // operation can run until Vcb release.
        InterlockedDecrement((PLONG)&(Fcb->CcbCount));
 
        UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
        if(PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_READ_ONLY)
            UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCountRO));
 
        if(!i || (Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB)) {
 
            AdPrint(("UDF: Closing volume\n"));
            AdPrint(("UDF: ReferenceCount:  %x\n",Fcb->ReferenceCount));
 
            if (Vcb->VCBOpenCount > UDF_RESIDUAL_REFERENCE) {
                ASSERT(Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB);
                UDFInterlockedDecrement((PLONG)&(Fcb->ReferenceCount));
                ASSERT(Fcb->NTRequiredFCB);
                UDFInterlockedDecrement((PLONG)&(Fcb->NTRequiredFCB->CommonRefCount));
 
                try_return(RC = STATUS_SUCCESS);
            }
 
            UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCount));
 
            if(AcquiredVcb) {
                UDFReleaseResource(&(Vcb->VCBResource));
                AcquiredVcb = FALSE;
            } else {
                BrutePoint();
            }
            // Acquire GlobalDataResource
            UDFAcquireResourceExclusive(&(UDFGlobalData.GlobalDataResource), TRUE);
            AcquiredGD = TRUE;
//            // Acquire Vcb
            UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
            AcquiredVcb = TRUE;
 
            UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
 
 
            ASSERT(Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB);
            UDFInterlockedDecrement((PLONG)&(Fcb->ReferenceCount));
            ASSERT(Fcb->NTRequiredFCB);
            UDFInterlockedDecrement((PLONG)&(Fcb->NTRequiredFCB->CommonRefCount));
 
            //AdPrint(("UDF: Closing volume, reset driver (e.g. stop BGF)\n"));
            //UDFResetDeviceDriver(Vcb, Vcb->TargetDeviceObject, FALSE);
 
            AdPrint(("UDF: Closing volume, reset write status\n"));
            RC = UDFPhSendIOCTL(IOCTL_CDRW_RESET_WRITE_STATUS, Vcb->TargetDeviceObject,
                NULL, 0, NULL, 0, TRUE, NULL);
 
            if((Vcb->VCBFlags & UDF_VCB_FLAGS_BEING_DISMOUNTED) ||
                ((!(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED)) && (Vcb->VCBOpenCount <= UDF_RESIDUAL_REFERENCE))) {
                // Try to KILL dismounted volume....
                // w2k requires this, NT4 - recomends
                AcquiredVcb = UDFCheckForDismount(PtrIrpContext, Vcb, TRUE);
            }
 
            try_return(RC = STATUS_SUCCESS);
        }
 
        fi = Fcb->FileInfo;
#ifdef UDF_DBG
        if(!fi) {
            BrutePoint();
        }
 
        DirNdx = UDFGetDirIndexByFileInfo(fi);
        if(DirNdx) {
            CurName.Buffer = UDFDirIndex(DirNdx,fi->Index)->FName.Buffer;
            if(CurName.Buffer) {
                AdPrint(("Closing file: %ws %8.8x\n", CurName.Buffer, FileObject));
            } else {
                AdPrint(("Closing file: ??? \n"));
            }
        }
        AdPrint(("UDF: ReferenceCount:  %x\n",Fcb->ReferenceCount));
#endif // UDF_DBG
        // try to clean up as long chain as it is possible
        UDFCleanUpFcbChain(Vcb, fi, i, TRUE);
 
try_exit: NOTHING;
 
    } _SEH2_FINALLY {
 
        if(AcquiredVcb) {
            UDFReleaseResource(&(Vcb->VCBResource));
        }
        if(AcquiredGD) {
            UDFReleaseResource(&(UDFGlobalData.GlobalDataResource));
        }
 
        // Post IRP if required
        if (PostRequest) {
 
            // Perform the post operation & complete the IRP
            // if this is first call of UDFCommonClose
            // and will return STATUS_SUCCESS back to us
            PtrIrpContext->Irp = NULL;
            PtrIrpContext->Fcb = Fcb;
            UDFPostRequest(PtrIrpContext, NULL);
        }
 
        if (!_SEH2_AbnormalTermination()) {
            // If this is not async close complete the IRP
            if (Irp) {
/*                if( FileObject ) {
                    if(clean_stat & UDF_CLOSE_NTREQFCB_DELETED) {
//                        ASSERT(!FileObject->FsContext2);
                        FileObject->FsContext = NULL;
#ifdef DBG
                    } else {
                        UDFNTRequiredFCB*  NtReqFcb = ((UDFNTRequiredFCB*)(FileObject->FsContext));
                        if(NtReqFcb->FileObject == FileObject) {
                            NtReqFcb->FileObject = NULL;
                        }
#endif //DBG
                    }
                }*/
                Irp->IoStatus.Status = STATUS_SUCCESS;
                Irp->IoStatus.Information = 0;
                IoCompleteRequest(Irp, IO_DISK_INCREMENT);
            }
            // Free up the Irp Context
            if(!PostRequest)
                UDFReleaseIrpContext(PtrIrpContext);
        }
 
    } _SEH2_END; // end of "__finally" processing
 
    return STATUS_SUCCESS ;
} // end UDFCommonClose()

Referenced by UDFClose(), UDFCommonDispatch(), and UDFDoDelayedClose().

UDFCommonCreate()

NTSTATUS UDFCommonCreate	(	IN PtrUDFIrpContext	PtrIrpContext,
		IN PIRP	Irp
	)

UDFCommonDeviceControl()

NTSTATUS NTAPI UDFCommonDeviceControl	(	PtrUDFIrpContext	PtrIrpContext,
		PIRP	Irp
	)

Definition at line 149 of file devcntrl.cpp.

{
    NTSTATUS                RC = STATUS_SUCCESS;
    PIO_STACK_LOCATION      IrpSp = NULL;
//    PIO_STACK_LOCATION      PtrNextIoStackLocation = NULL;
    PFILE_OBJECT            FileObject = NULL;
    PtrUDFFCB               Fcb = NULL;
    PtrUDFCCB               Ccb = NULL;
    PVCB                    Vcb = NULL;
    BOOLEAN                 CompleteIrp = FALSE;
    ULONG                   IoControlCode = 0;
//    PVOID                   BufferPointer = NULL;
    BOOLEAN                 AcquiredVcb = FALSE;
    BOOLEAN                 FSDevObj;
    ULONG                   TrackNumber;
    BOOLEAN                 UnsafeIoctl = TRUE;
    UCHAR                   ScsiCommand;
    PPREVENT_MEDIA_REMOVAL_USER_IN Buf = NULL;    // FSD buffer
    PCDB                    Cdb;
    PCHAR                   CdbData;
    PCHAR                   ModeSelectData;
 
    UDFPrint(("UDFCommonDeviceControl\n"));
 
    _SEH2_TRY {
        // First, get a pointer to the current I/O stack location
        IrpSp = IoGetCurrentIrpStackLocation(Irp);
        ASSERT(IrpSp);
 
        // Get the IoControlCode value
        IoControlCode = IrpSp->Parameters.DeviceIoControl.IoControlCode;
 
        FileObject = IrpSp->FileObject;
        ASSERT(FileObject);
 
        FSDevObj = UDFIsFSDevObj(PtrIrpContext->TargetDeviceObject);
 
        if(FSDevObj) {
            switch (IoControlCode) {
            case IOCTL_UDF_DISABLE_DRIVER:
            case IOCTL_UDF_INVALIDATE_VOLUMES:
            case IOCTL_UDF_SET_NOTIFICATION_EVENT:
#ifndef UDF_READ_ONLY_BUILD
            case IOCTL_UDF_SEND_LICENSE_KEY:
#endif //UDF_READ_ONLY_BUILD
            case IOCTL_UDF_REGISTER_AUTOFORMAT:
                break;
            default:
                UDFPrint(("UDFCommonDeviceControl: STATUS_INVALID_PARAMETER %x for FsDevObj\n", IoControlCode));
                CompleteIrp = TRUE;
                try_return(RC = STATUS_INVALID_PARAMETER);
            }
        } else {
            Ccb = (PtrUDFCCB)(FileObject->FsContext2);
            if(!Ccb) {
                UDFPrint(("  !Ccb\n"));
                goto ioctl_do_default;
            }
            ASSERT(Ccb);
            Fcb = Ccb->Fcb;
            ASSERT(Fcb);
 
            // Check if the IOCTL is suitable for this type of File
            if (Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB) {
                // Everything is acceptable for Volume
                Vcb = (PVCB)(Fcb);
            } else {
                Vcb = Fcb->Vcb;
                CompleteIrp = TRUE;
                // For files/disrs only the following are acceptable
                switch (IoControlCode) {
                case IOCTL_UDF_GET_RETRIEVAL_POINTERS:
                case IOCTL_UDF_GET_FILE_ALLOCATION_MODE:
                case IOCTL_UDF_SET_FILE_ALLOCATION_MODE:
                    break;
                default:
                    UDFPrint(("UDFCommonDeviceControl: STATUS_INVALID_PARAMETER %x for File/Dir Obj\n", IoControlCode));
                    try_return(RC = STATUS_INVALID_PARAMETER);
                }
            }
            // check 'safe' IOCTLs
            switch (IoControlCode) {
            case IOCTL_CDROM_RAW_READ:
 
            case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
            case IOCTL_DISK_GET_DRIVE_GEOMETRY:
            case IOCTL_DISK_GET_PARTITION_INFO:
            case IOCTL_DISK_GET_DRIVE_LAYOUT:
 
            case IOCTL_CDROM_GET_DRIVE_GEOMETRY_EX:
            case IOCTL_DISK_GET_PARTITION_INFO_EX:
            case IOCTL_DISK_GET_DRIVE_LAYOUT_EX:
            case IOCTL_DISK_GET_DRIVE_GEOMETRY_EX:
 
            case IOCTL_STORAGE_CHECK_VERIFY:
            case IOCTL_STORAGE_CHECK_VERIFY2:
            case IOCTL_DISK_CHECK_VERIFY:
            case IOCTL_CDROM_CHECK_VERIFY:
 
            case IOCTL_CDROM_LOAD_MEDIA:
            case IOCTL_DISK_LOAD_MEDIA:
            case IOCTL_STORAGE_LOAD_MEDIA:
            case IOCTL_STORAGE_LOAD_MEDIA2:
 
            case IOCTL_CDROM_GET_CONFIGURATION:
            case IOCTL_CDROM_GET_LAST_SESSION:
            case IOCTL_CDROM_READ_TOC:
            case IOCTL_CDROM_READ_TOC_EX:
            case IOCTL_CDROM_PLAY_AUDIO_MSF:
            case IOCTL_CDROM_READ_Q_CHANNEL:
            case IOCTL_CDROM_PAUSE_AUDIO:
            case IOCTL_CDROM_RESUME_AUDIO:
            case IOCTL_CDROM_SEEK_AUDIO_MSF:
            case IOCTL_CDROM_STOP_AUDIO:
            case IOCTL_CDROM_GET_CONTROL:
            case IOCTL_CDROM_GET_VOLUME:
            case IOCTL_CDROM_SET_VOLUME:
 
            case IOCTL_CDRW_SET_SPEED:
            case IOCTL_CDRW_GET_CAPABILITIES:
            case IOCTL_CDRW_GET_MEDIA_TYPE_EX:
            case IOCTL_CDRW_GET_MEDIA_TYPE:
 
            case IOCTL_DISK_GET_MEDIA_TYPES:
            case IOCTL_STORAGE_GET_MEDIA_TYPES:
            case IOCTL_STORAGE_GET_MEDIA_TYPES_EX:
 
            case IOCTL_DISK_IS_WRITABLE:
 
            case IOCTL_CDRW_GET_WRITE_MODE:
            case IOCTL_CDRW_READ_TRACK_INFO:
            case IOCTL_CDRW_READ_DISC_INFO:
            case IOCTL_CDRW_BUFFER_CAPACITY:
            case IOCTL_CDRW_GET_SIGNATURE:
            case IOCTL_CDRW_TEST_UNIT_READY:
            case IOCTL_CDRW_GET_LAST_ERROR:
            case IOCTL_CDRW_MODE_SENSE:
            case IOCTL_CDRW_LL_READ:
            case IOCTL_CDRW_READ_ATIP:
            case IOCTL_CDRW_READ_CD_TEXT:
            case IOCTL_CDRW_READ_TOC_EX:
            case IOCTL_CDRW_READ_FULL_TOC:
            case IOCTL_CDRW_READ_PMA:
            case IOCTL_CDRW_READ_SESSION_INFO:
            case IOCTL_CDRW_GET_DEVICE_INFO:
            case IOCTL_CDRW_GET_EVENT:
 
            case IOCTL_DVD_READ_STRUCTURE:
 
            case IOCTL_CDRW_GET_DEVICE_NAME:
            case IOCTL_MOUNTDEV_QUERY_DEVICE_NAME:
 
            case IOCTL_UDF_GET_RETRIEVAL_POINTERS:
            case IOCTL_UDF_GET_SPEC_RETRIEVAL_POINTERS:
            case IOCTL_UDF_GET_FILE_ALLOCATION_MODE:
            case IOCTL_UDF_GET_VERSION:
            case IOCTL_UDF_IS_VOLUME_JUST_MOUNTED:
            case IOCTL_UDF_SET_OPTIONS:
//            case :
 
            case FSCTL_IS_VOLUME_DIRTY:
 
                UnsafeIoctl = FALSE;
                break;
            }
 
            if(IoControlCode != IOCTL_CDROM_DISK_TYPE) {
                UDFAcquireResourceShared(&(Vcb->VCBResource), TRUE);
            } else {
                UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
            }
            AcquiredVcb = TRUE;
        }
 
        UDFPrint(("UDF Irp %x, ctx %x, DevIoCtl %x\n", Irp, PtrIrpContext, IoControlCode));
 
        // We may wish to allow only   volume open operations.
        switch (IoControlCode) {
 
        case IOCTL_SCSI_PASS_THROUGH_DIRECT:
        case IOCTL_SCSI_PASS_THROUGH:
 
            if(!Irp->AssociatedIrp.SystemBuffer)
                goto ioctl_do_default;
 
            if(IoControlCode == IOCTL_SCSI_PASS_THROUGH_DIRECT) {
                Cdb = (PCDB)&(((PSCSI_PASS_THROUGH_DIRECT)(Irp->AssociatedIrp.SystemBuffer))->Cdb);
                CdbData = (PCHAR)(((PSCSI_PASS_THROUGH_DIRECT)(Irp->AssociatedIrp.SystemBuffer))->DataBuffer);
            } else {
                Cdb = (PCDB)&(((PSCSI_PASS_THROUGH)(Irp->AssociatedIrp.SystemBuffer))->Cdb);
                if(((PSCSI_PASS_THROUGH)(Irp->AssociatedIrp.SystemBuffer))->DataBufferOffset) {
                    CdbData = ((PCHAR)Cdb) +
                              ((PSCSI_PASS_THROUGH)(Irp->AssociatedIrp.SystemBuffer))->DataBufferOffset;
                } else {
                    CdbData = NULL;
                }
            }
            ScsiCommand = Cdb->CDB6.OperationCode;
 
            if(ScsiCommand == SCSIOP_WRITE_CD) {
                UDFPrint(("Write10, LBA %2.2x%2.2x%2.2x%2.2x\n",
                         Cdb->WRITE_CD.LBA[0],
                         Cdb->WRITE_CD.LBA[1],
                         Cdb->WRITE_CD.LBA[2],
                         Cdb->WRITE_CD.LBA[3]
                         ));
            } else
            if(ScsiCommand == SCSIOP_WRITE12) {
                UDFPrint(("Write12, LBA %2.2x%2.2x%2.2x%2.2x\n",
                         Cdb->CDB12READWRITE.LBA[0],
                         Cdb->CDB12READWRITE.LBA[1],
                         Cdb->CDB12READWRITE.LBA[2],
                         Cdb->CDB12READWRITE.LBA[3]
                         ));
            } else {
            }
 
            switch(ScsiCommand) {
            case SCSIOP_MODE_SELECT: {
//                PMODE_PARAMETER_HEADER ParamHdr = (PMODE_PARAMETER_HEADER)CdbData;
                ModeSelectData = CdbData+4;
                switch(ModeSelectData[0]) {
                case MODE_PAGE_MRW2:
                case MODE_PAGE_WRITE_PARAMS:
                case MODE_PAGE_MRW:
                    UDFPrint(("Unsafe MODE_SELECT_6 via pass-through (%2.2x)\n", ModeSelectData[0]));
                    goto unsafe_direct_scsi_cmd;
                }
                break; }
 
            case SCSIOP_MODE_SELECT10: {
//                PMODE_PARAMETER_HEADER10 ParamHdr = (PMODE_PARAMETER_HEADER10)CdbData;
                ModeSelectData = CdbData+8;
                switch(ModeSelectData[0]) {
                case MODE_PAGE_MRW2:
                case MODE_PAGE_WRITE_PARAMS:
                case MODE_PAGE_MRW:
                    UDFPrint(("Unsafe MODE_SELECT_10 via pass-through (%2.2x)\n", ModeSelectData[0]));
                    goto unsafe_direct_scsi_cmd;
                }
                break; }
 
            case SCSIOP_RESERVE_TRACK:
            case SCSIOP_SEND_CUE_SHEET:
            case SCSIOP_SEND_DVD_STRUCTURE:
            case SCSIOP_CLOSE_TRACK_SESSION:
            case SCSIOP_FORMAT_UNIT:
            case SCSIOP_WRITE6:
            case SCSIOP_WRITE_CD:
            case SCSIOP_BLANK:
            case SCSIOP_WRITE12:
            case SCSIOP_SET_STREAMING:
                UDFPrint(("UDF Direct media modification via pass-through (%2.2x)\n", ScsiCommand));
unsafe_direct_scsi_cmd:
                if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED))
                    goto ioctl_do_default;
 
                UDFPrint(("Forget this volume\n"));
                // Acquire Vcb resource (Shared -> Exclusive)
                UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCount));
                UDFReleaseResource(&(Vcb->VCBResource));
 
                if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK)) {
                    UDFCloseAllSystemDelayedInDir(Vcb, Vcb->RootDirFCB->FileInfo);
                }
#ifdef UDF_DELAYED_CLOSE
                //  Acquire exclusive access to the Vcb.
                UDFCloseAllDelayed(Vcb);
#endif //UDF_DELAYED_CLOSE
 
                // allocate tmp buffer for FSD calls
                Buf = (PPREVENT_MEDIA_REMOVAL_USER_IN)MyAllocatePool__(NonPagedPool, sizeof(PREVENT_MEDIA_REMOVAL_USER_IN));
                if(!Buf)
                    try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
 
                UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
                AcquiredVcb = TRUE;
                UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
 
                UDFDoDismountSequence(Vcb, Buf, FALSE);
                MyFreePool__(Buf);
                Buf = NULL;
                Vcb->MediaLockCount = 0;
 
                Vcb->VCBFlags &= ~UDF_VCB_FLAGS_VOLUME_MOUNTED;
                Vcb->WriteSecurity = FALSE;
 
                // Release the Vcb resource.
                UDFReleaseResource(&(Vcb->VCBResource));
                AcquiredVcb = FALSE;
                // disable Eject Request Waiter if any
                UDFStopEjectWaiter(Vcb);
 
                // Make sure, that volume will never be quick-remounted
                // It is very important for ChkUdf utility and
                // some CD-recording libraries
                Vcb->SerialNumber--;
 
                UDFPrint(("Forgotten\n"));
 
                goto notify_media_change;
 
            case SCSIOP_START_STOP_UNIT:
            case SCSIOP_DOORLOCK:
            case SCSIOP_DOORUNLOCK:
            case SCSIOP_MEDIUM_REMOVAL:
                UDFPrint(("UDF Medium/Tray control IOCTL via pass-through\n"));
            }
            goto ioctl_do_default;
 
        case IOCTL_CDRW_BLANK:
        case IOCTL_CDRW_LL_WRITE:
        case IOCTL_CDRW_FORMAT_UNIT:
 
notify_media_change:
/*            Vcb->VCBFlags |= UDF_VCB_FLAGS_UNSAFE_IOCTL;
            // Make sure, that volume will never be quick-remounted
            // It is very important for ChkUdf utility and
            // some CD-recording libraries
            Vcb->SerialNumber--;
*/          goto ioctl_do_default;
 
        case IOCTL_UDF_REGISTER_AUTOFORMAT: {
 
            UDFPrint(("UDF Register Autoformat\n"));
            if(UDFGlobalData.AutoFormatCount) {
                RC = STATUS_SHARING_VIOLATION;
            } else {
                UDFGlobalData.AutoFormatCount = FileObject;
                RC = STATUS_SUCCESS;
            }
            CompleteIrp = TRUE;
            Irp->IoStatus.Information = 0;
            break;
        }
 
        case IOCTL_UDF_DISABLE_DRIVER: {
 
            UDFPrint(("UDF Disable driver\n"));
            IoUnregisterFileSystem(UDFGlobalData.UDFDeviceObject);
            // Now, delete any device objects, etc. we may have created
            if (UDFGlobalData.UDFDeviceObject) {
                IoDeleteDevice(UDFGlobalData.UDFDeviceObject);
                UDFGlobalData.UDFDeviceObject = NULL;
            }
 
            // free up any memory we might have reserved for zones/lookaside
            //  lists
            if (UDFGlobalData.UDFFlags & UDF_DATA_FLAGS_ZONES_INITIALIZED) {
                UDFDestroyZones();
            }
 
            // delete the resource we may have initialized
            if (UDFGlobalData.UDFFlags & UDF_DATA_FLAGS_RESOURCE_INITIALIZED) {
                // un-initialize this resource
                UDFDeleteResource(&(UDFGlobalData.GlobalDataResource));
                UDFClearFlag(UDFGlobalData.UDFFlags, UDF_DATA_FLAGS_RESOURCE_INITIALIZED);
            }
            RC = STATUS_SUCCESS;
            CompleteIrp = TRUE;
            Irp->IoStatus.Information = 0;
            break;
        }
        case IOCTL_UDF_INVALIDATE_VOLUMES: {
            UDFPrint(("UDF Invaidate volume\n"));
            if(AcquiredVcb) {
                UDFReleaseResource(&(Vcb->VCBResource));
                AcquiredVcb = FALSE;
            }
            RC = UDFInvalidateVolumes( PtrIrpContext, Irp );
            CompleteIrp = TRUE;
            Irp->IoStatus.Information = 0;
            break;
        }
 
        case IOCTL_UDF_SET_NOTIFICATION_EVENT:
        {
            if (IrpSp->Parameters.DeviceIoControl.InputBufferLength != sizeof(HANDLE))
            {
                RC = STATUS_INVALID_PARAMETER;
            }
            else
            {
                HANDLE MountEventHandle = *(PHANDLE)Irp->AssociatedIrp.SystemBuffer;
                if (MountEventHandle)
                {
                    if (!UDFGlobalData.MountEvent)
                    {
                        RC = ObReferenceObjectByHandle(
                            MountEventHandle,
                            0,
                            NULL,
                            UserMode,
                            (PVOID *) &UDFGlobalData.MountEvent,
                            NULL);
 
                        if (!NT_SUCCESS(RC))
                        {
                            UDFGlobalData.MountEvent = NULL;
                        }
                    }
                    else
                    {
                        RC = STATUS_INVALID_PARAMETER;
                    }
                }
                else
                {
                    if (!UDFGlobalData.MountEvent)
                    {
                        RC = STATUS_INVALID_PARAMETER;
                    }
                    else
                    {
                        ObDereferenceObject(UDFGlobalData.MountEvent);
                        UDFGlobalData.MountEvent = NULL;
                    }
                }
            }
 
            CompleteIrp = TRUE;
            Irp->IoStatus.Information = 0;
            break;
        }
 
        case IOCTL_UDF_IS_VOLUME_JUST_MOUNTED:
        {
            if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(BOOLEAN))
            {
                RC = STATUS_INVALID_PARAMETER;
            }
            else
            {
                *(PBOOLEAN)Irp->AssociatedIrp.SystemBuffer = Vcb->IsVolumeJustMounted;
                Vcb->IsVolumeJustMounted = FALSE;
            }
 
            CompleteIrp = TRUE;
            Irp->IoStatus.Information = 0;
            break;
        }
 
 
        //case FSCTL_GET_RETRIEVAL_POINTERS
        case IOCTL_UDF_GET_RETRIEVAL_POINTERS: {
            UDFPrint(("UDF: Get Retrieval Pointers\n"));
            RC = UDFGetRetrievalPointers( PtrIrpContext, Irp, 0 );
            CompleteIrp = TRUE;
            break;
        }
        case IOCTL_UDF_GET_SPEC_RETRIEVAL_POINTERS: {
            UDFPrint(("UDF: Get Spec Retrieval Pointers\n"));
            PUDF_GET_SPEC_RETRIEVAL_POINTERS_IN SpecRetrPointer;
            SpecRetrPointer = (PUDF_GET_SPEC_RETRIEVAL_POINTERS_IN)(Irp->AssociatedIrp.SystemBuffer);
            RC = UDFGetRetrievalPointers( PtrIrpContext, Irp, SpecRetrPointer->Special );
            CompleteIrp = TRUE;
            break;
        }
        case IOCTL_UDF_GET_FILE_ALLOCATION_MODE: {
            UDFPrint(("UDF: Get File Alloc mode (from ICB)\n"));
            RC = UDFGetFileAllocModeFromICB( PtrIrpContext, Irp );
            CompleteIrp = TRUE;
            break;
        }
#ifndef UDF_READ_ONLY_BUILD
        case IOCTL_UDF_SET_FILE_ALLOCATION_MODE: {
            UDFPrint(("UDF: Set File Alloc mode\n"));
            RC = UDFSetFileAllocModeFromICB( PtrIrpContext, Irp );
            CompleteIrp = TRUE;
            break;
        }
#endif //UDF_READ_ONLY_BUILD
        case IOCTL_UDF_LOCK_VOLUME_BY_PID:
            if(AcquiredVcb) {
                UDFReleaseResource(&(Vcb->VCBResource));
                AcquiredVcb = FALSE;
            }
            RC = UDFLockVolume( PtrIrpContext, Irp, GetCurrentPID() );
            CompleteIrp = TRUE;
            break;
        case IOCTL_UDF_UNLOCK_VOLUME_BY_PID:
            if(AcquiredVcb) {
                UDFReleaseResource(&(Vcb->VCBResource));
                AcquiredVcb = FALSE;
            }
            RC = UDFUnlockVolume( PtrIrpContext, Irp, GetCurrentPID() );
            CompleteIrp = TRUE;
            break;
#ifndef UDF_READ_ONLY_BUILD
        case IOCTL_UDF_SEND_LICENSE_KEY:
            RC = STATUS_SUCCESS;
 
            Irp->IoStatus.Information = 0;
            Irp->IoStatus.Status = STATUS_SUCCESS;
            CompleteIrp = TRUE;
            break;
#endif //UDF_READ_ONLY_BUILD
        case IOCTL_UDF_GET_VERSION: {
 
            PUDF_GET_VERSION_OUT udf_ver;
 
            UDFPrint(("UDFUserFsCtrlRequest: IOCTL_UDF_GET_VERSION\n"));
 
            Irp->IoStatus.Information = 0;
            CompleteIrp = TRUE;
 
            if(!IrpSp->Parameters.DeviceIoControl.OutputBufferLength) {
                UDFPrint(("!OutputBufferLength\n"));
                try_return(RC = STATUS_SUCCESS);
            }
            //  Check the size of the output buffer.
            if(IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(UDF_GET_VERSION_OUT)) {
                UDFPrint(("OutputBufferLength < %x\n", sizeof(UDF_GET_VERSION_OUT)));
                try_return(RC = STATUS_BUFFER_TOO_SMALL);
            }
 
            udf_ver = (PUDF_GET_VERSION_OUT)(Irp->AssociatedIrp.SystemBuffer);
            if(!udf_ver) {
                UDFPrint(("!udf_ver\n"));
                try_return(RC = STATUS_INVALID_USER_BUFFER);
            }
 
            RtlZeroMemory(udf_ver, IrpSp->Parameters.DeviceIoControl.OutputBufferLength);
 
            udf_ver->header.Length = sizeof(UDF_GET_VERSION_OUT);
            udf_ver->header.DriverVersionMj    = 0x00010005;
            udf_ver->header.DriverVersionMn    = 0x12;
            udf_ver->header.DriverVersionBuild = UDF_CURRENT_BUILD;
 
            udf_ver->FSVersionMj = Vcb->CurrentUDFRev >> 8;
            udf_ver->FSVersionMn = Vcb->CurrentUDFRev & 0xff;
            udf_ver->FSFlags     = Vcb->UserFSFlags;
            if( ((Vcb->origIntegrityType == INTEGRITY_TYPE_OPEN) &&
                (Vcb->CompatFlags & UDF_VCB_IC_DIRTY_RO))
                    ||
               (Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY) ) {
                UDFPrint(("  UDF_USER_FS_FLAGS_RO\n"));
                udf_ver->FSFlags |= UDF_USER_FS_FLAGS_RO;
            }
            if(Vcb->VCBFlags & UDF_VCB_FLAGS_OUR_DEVICE_DRIVER) {
                UDFPrint(("  UDF_USER_FS_FLAGS_OUR_DRIVER\n"));
                udf_ver->FSFlags |= UDF_USER_FS_FLAGS_OUR_DRIVER;
            }
            if(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK) {
                UDFPrint(("  UDF_USER_FS_FLAGS_RAW\n"));
                udf_ver->FSFlags |= UDF_USER_FS_FLAGS_RAW;
            }
            if(Vcb->VCBFlags & UDF_VCB_FLAGS_MEDIA_READ_ONLY) {
                UDFPrint(("  UDF_USER_FS_FLAGS_MEDIA_RO\n"));
                udf_ver->FSFlags |= UDF_USER_FS_FLAGS_MEDIA_RO;
            }
            if(Vcb->FP_disc) {
                UDFPrint(("  UDF_USER_FS_FLAGS_FP\n"));
                udf_ver->FSFlags |= UDF_USER_FS_FLAGS_FP;
            }
            udf_ver->FSCompatFlags = Vcb->CompatFlags;
 
            udf_ver->FSCfgVersion = Vcb->CfgVersion;
 
            Irp->IoStatus.Information = sizeof(UDF_GET_VERSION_OUT);
            RC = STATUS_SUCCESS;
            CompleteIrp = TRUE;
 
            break; }
        case IOCTL_UDF_SET_OPTIONS: {
 
            PUDF_SET_OPTIONS_IN udf_opt;
            BOOLEAN PrevVerifyOnWrite;
 
            UDFPrint(("UDF: IOCTL_UDF_SET_OPTIONS\n"));
 
            Irp->IoStatus.Information = 0;
            CompleteIrp = TRUE;
 
            if(IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(UDF_SET_OPTIONS_IN)) {
                UDFPrint(("InputBufferLength < %x\n", sizeof(UDF_SET_OPTIONS_IN)));
                try_return(RC = STATUS_BUFFER_TOO_SMALL);
            }
 
            udf_opt = (PUDF_SET_OPTIONS_IN)(Irp->AssociatedIrp.SystemBuffer);
            if(!udf_opt) {
                UDFPrint(("!udf_opt\n"));
                try_return(RC = STATUS_INVALID_USER_BUFFER);
            }
 
            if((udf_opt->header.Flags & UDF_SET_OPTIONS_FLAG_MASK) != UDF_SET_OPTIONS_FLAG_TEMPORARY) {
                UDFPrint(("invalid opt target\n"));
                try_return(RC = STATUS_INVALID_PARAMETER);
            }
 
            if(AcquiredVcb) {
                UDFReleaseResource(&(Vcb->VCBResource));
                AcquiredVcb = FALSE;
            }
            UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
            AcquiredVcb = TRUE;
 
            PrevVerifyOnWrite = Vcb->VerifyOnWrite;
 
            Vcb->Cfg = ((PUCHAR)(udf_opt)) + udf_opt->header.HdrLength;
            Vcb->CfgLength = IrpSp->Parameters.DeviceIoControl.InputBufferLength - offsetof(UDF_SET_OPTIONS_IN, Data);
            UDFReadRegKeys(Vcb, TRUE /*update*/, TRUE /*cfg*/);
            Vcb->Cfg = NULL;
            Vcb->CfgLength = 0;
            Vcb->CfgVersion++;
            //UDFReadRegKeys(Vcb, TRUE /*update*/, TRUE);
            if(PrevVerifyOnWrite != Vcb->VerifyOnWrite) {
                if(Vcb->VerifyOnWrite) {
                    UDFVInit(Vcb);
                } else {
                    WCacheFlushBlocks__(&(Vcb->FastCache), Vcb, 0, Vcb->LastLBA);
                    UDFVFlush(Vcb);
                    UDFVRelease(Vcb);
                }
            }
 
            RC = STATUS_SUCCESS;
            break; }
#if 0
        case IOCTL_UDF_GET_OPTIONS_VERSION: {
 
            PUDF_GET_OPTIONS_VERSION_OUT udf_opt_ver;
 
            UDFPrint(("UDF: IOCTL_UDF_GET_OPTIONS_VERSION\n"));
 
            Irp->IoStatus.Information = 0;
            CompleteIrp = TRUE;
 
            if(IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(UDF_GET_OPTIONS_VERSION_OUT)) {
                UDFPrint(("OutputBufferLength < %x\n", sizeof(UDF_GET_OPTIONS_VERSION_OUT)));
                try_return(RC = STATUS_BUFFER_TOO_SMALL);
            }
 
            udf_opt_ver = (PUDF_GET_OPTIONS_VERSION_OUT)(Irp->AssociatedIrp.SystemBuffer);
            if(!udf_opt_ver) {
                UDFPrint(("!udf_opt-ver\n"));
                try_return(RC = STATUS_INVALID_USER_BUFFER);
            }
/*
            if(AcquiredVcb) {
                UDFReleaseResource(&(Vcb->VCBResource));
                AcquiredVcb = FALSE;
            }
            UDFAcquireResourceShared(&(Vcb->VCBResource), TRUE);
            AcquiredVcb = TRUE;
*/
            udf_opt_ver->CfgVersion = Vcb->CfgVersion;
            Irp->IoStatus.Information = sizeof(UDF_GET_OPTIONS_VERSION_OUT);
 
            RC = STATUS_SUCCESS;
            break; }
#endif //0
        case IOCTL_CDRW_RESET_DRIVER:
 
            UDFPrint(("UDF: IOCTL_CDRW_RESET_DRIVER\n"));
            Vcb->MediaLockCount = 0;
            Vcb->VCBFlags &= ~UDF_VCB_FLAGS_MEDIA_LOCKED;
            goto ioctl_do_default;
 
        case FSCTL_ALLOW_EXTENDED_DASD_IO:
 
            UDFPrint(("UDFUserFsCtrlRequest: FSCTL_ALLOW_EXTENDED_DASD_IO\n"));
            // DASD i/o is always permitted
            // So, no-op this call
            RC = STATUS_SUCCESS;
 
            Irp->IoStatus.Information = 0;
            Irp->IoStatus.Status = STATUS_SUCCESS;
            CompleteIrp = TRUE;
            break;
 
        case FSCTL_IS_VOLUME_DIRTY:
 
            UDFPrint(("UDFUserFsCtrlRequest: FSCTL_IS_VOLUME_DIRTY\n"));
            // DASD i/o is always permitted
            // So, no-op this call
            RC = UDFIsVolumeDirty(PtrIrpContext, Irp);
            CompleteIrp = TRUE;
            break;
 
        case IOCTL_STORAGE_EJECT_MEDIA:
        case IOCTL_DISK_EJECT_MEDIA:
        case IOCTL_CDROM_EJECT_MEDIA: {
 
            UDFPrint(("UDF Reset/Eject request\n"));
//            PPREVENT_MEDIA_REMOVAL_USER_IN Buf;
 
            if(Vcb->EjectWaiter) {
                UDFPrint(("  Vcb->EjectWaiter present\n"));
                Irp->IoStatus.Information = 0;
                Vcb->EjectWaiter->SoftEjectReq = TRUE;
                Vcb->SoftEjectReq = TRUE;
                CompleteIrp = TRUE;
                try_return(RC = STATUS_SUCCESS);
            }
            UDFPrint(("  !Vcb->EjectWaiter\n"));
            goto ioctl_do_default;
/*
            Buf = (PPREVENT_MEDIA_REMOVAL_USER_IN)MyAllocatePool__(NonPagedPool, sizeof(PREVENT_MEDIA_REMOVAL_USER_IN));
            if(!Buf) try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
            // Acquire Vcb resource (Shared -> Exclusive)
            UDFReleaseResource(&(Vcb->VCBResource));
            UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
 
            Vcb->Vpb->RealDevice->Flags |= DO_VERIFY_VOLUME;
            Vcb->VCBFlags &= ~UDF_VCB_FLAGS_VOLUME_MOUNTED;
 
            UDFDoDismountSequence(Vcb, Buf, IoControlCode == IOCTL_CDROM_EJECT_MEDIA);
            // disable Eject Request Waiter if any
            MyFreePool__(Buf);
            // Release the Vcb resource.
            UDFReleaseResource(&(Vcb->VCBResource));
            AcquiredVcb = FALSE;
            UDFStopEjectWaiter(Vcb);
            CompleteIrp = TRUE;
            RC = STATUS_SUCCESS;
            break;*/
        }
        case IOCTL_CDROM_DISK_TYPE: {
 
            UDFPrint(("UDF Cdrom Disk Type\n"));
            CompleteIrp = TRUE;
            //  Verify the Vcb in this case to detect if the volume has changed.
            Irp->IoStatus.Information = 0;
            RC = UDFVerifyVcb(PtrIrpContext,Vcb);
            if(!NT_SUCCESS(RC))
                try_return(RC);
 
            //  Check the size of the output buffer.
            if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(CDROM_DISK_DATA_USER_OUT))
                try_return(RC = STATUS_BUFFER_TOO_SMALL);
 
            //  Copy the data from the Vcb.
            ((PCDROM_DISK_DATA_USER_OUT)(Irp->AssociatedIrp.SystemBuffer))->DiskData = CDROM_DISK_DATA_TRACK;
            for(TrackNumber=Vcb->FirstTrackNum; TrackNumber<Vcb->LastTrackNum; TrackNumber++) {
                if((Vcb->TrackMap[TrackNumber].TrackParam & Trk_QSubChan_Type_Mask) ==
                    Trk_QSubChan_Type_Audio) {
                    ((PCDROM_DISK_DATA_USER_OUT)(Irp->AssociatedIrp.SystemBuffer))->DiskData |= CDROM_DISK_AUDIO_TRACK;
                    break;
                }
            }
 
            Irp->IoStatus.Information = sizeof(CDROM_DISK_DATA_USER_OUT);
            RC = STATUS_SUCCESS;
            break;
        }
 
        case IOCTL_CDRW_LOCK_DOOR:
        case IOCTL_STORAGE_MEDIA_REMOVAL:
        case IOCTL_DISK_MEDIA_REMOVAL:
        case IOCTL_CDROM_MEDIA_REMOVAL: {
            UDFPrint(("UDF Lock/Unlock\n"));
            PPREVENT_MEDIA_REMOVAL_USER_IN buffer; // user supplied buffer
            buffer = (PPREVENT_MEDIA_REMOVAL_USER_IN)(Irp->AssociatedIrp.SystemBuffer);
            if(!buffer) {
                if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED)) {
                    UDFPrint(("!mounted\n"));
                    goto ioctl_do_default;
                }
                UDFPrint(("abort\n"));
                CompleteIrp = TRUE;
                Irp->IoStatus.Information = 0;
                UnsafeIoctl = FALSE;
                RC = STATUS_INVALID_PARAMETER;
                break;
            }
            if(!buffer->PreventMediaRemoval &&
               !Vcb->MediaLockCount) {
 
                UDFPrint(("!locked + unlock req\n"));
                if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED)) {
                    UDFPrint(("!mounted\n"));
                    goto ioctl_do_default;
                }
#if 0
                // allocate tmp buffer for FSD calls
                Buf = (PPREVENT_MEDIA_REMOVAL_USER_IN)MyAllocatePool__(NonPagedPool, sizeof(PREVENT_MEDIA_REMOVAL_USER_IN));
                if(!Buf)
                    try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
 
                // Acquire Vcb resource (Shared -> Exclusive)
                UDFInterlockedIncrement((PLONG)&(Vcb->VCBOpenCount));
                UDFReleaseResource(&(Vcb->VCBResource));
 
#ifdef UDF_DELAYED_CLOSE
                //  Acquire exclusive access to the Vcb.
                UDFCloseAllDelayed(Vcb);
#endif //UDF_DELAYED_CLOSE
 
                UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
                UDFInterlockedDecrement((PLONG)&(Vcb->VCBOpenCount));
 
                UDFDoDismountSequence(Vcb, Buf, FALSE);
                MyFreePool__(Buf);
                Buf = NULL;
                Vcb->MediaLockCount = 0;
                // Release the Vcb resource.
                UDFReleaseResource(&(Vcb->VCBResource));
                AcquiredVcb = FALSE;
                // disable Eject Request Waiter if any
                UDFStopEjectWaiter(Vcb);
#else
                // just ignore
#endif
ignore_lock:
                UDFPrint(("ignore lock/unlock\n"));
                CompleteIrp = TRUE;
                Irp->IoStatus.Information = 0;
                RC = STATUS_SUCCESS;
                break;
            }
            if(buffer->PreventMediaRemoval) {
                UDFPrint(("lock req\n"));
                Vcb->MediaLockCount++;
                Vcb->VCBFlags |= UDF_VCB_FLAGS_MEDIA_LOCKED;
                UnsafeIoctl = FALSE;
            } else {
                UDFPrint(("unlock req\n"));
                if(Vcb->MediaLockCount) {
                    UDFPrint(("lock count %d\n", Vcb->MediaLockCount));
                    UnsafeIoctl = FALSE;
                    Vcb->MediaLockCount--;
                }
            }
            if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED)) {
                UDFPrint(("!mounted\n"));
                goto ioctl_do_default;
            }
            goto ignore_lock;
        }
        default:
 
            UDFPrint(("default processing Irp %x, ctx %x, DevIoCtl %x\n", Irp, PtrIrpContext, IoControlCode));
ioctl_do_default:
 
            // make sure volume is Sync'ed BEFORE sending unsafe IOCTL
            if(Vcb && UnsafeIoctl) {
                UDFFlushLogicalVolume(NULL, NULL, Vcb, 0);
                UDFPrint(("  sync'ed\n"));
            }
            // Invoke the lower level driver in the chain.
            //PtrNextIoStackLocation = IoGetNextIrpStackLocation(Irp);
            //*PtrNextIoStackLocation = *IrpSp;
            IoSkipCurrentIrpStackLocation(Irp);
/*
            // Set a completion routine.
            IoSetCompletionRoutine(Irp, UDFDevIoctlCompletion, PtrIrpContext, TRUE, TRUE, TRUE);
            // Send the request.
*/
            RC = IoCallDriver(Vcb->TargetDeviceObject, Irp);
            if(!CompleteIrp) {
                // since now we do not use IoSetCompletionRoutine()
                UDFReleaseIrpContext(PtrIrpContext);
            }
            break;
        }
 
        if(Vcb && UnsafeIoctl) {
            UDFPrint(("  set UnsafeIoctl\n"));
            Vcb->VCBFlags |= UDF_VCB_FLAGS_UNSAFE_IOCTL;
        }
 
try_exit: NOTHING;
 
    } _SEH2_FINALLY {
 
        if(AcquiredVcb) {
            UDFReleaseResource(&(Vcb->VCBResource));
            AcquiredVcb = FALSE;
        }
 
        if(Buf) {
            MyFreePool__(Buf);
        }
 
        if (!_SEH2_AbnormalTermination() &&
            CompleteIrp) {
            UDFPrint(("  complete Irp %x, ctx %x, status %x, iolen %x\n",
                Irp, PtrIrpContext, RC, Irp->IoStatus.Information));
            Irp->IoStatus.Status = RC;
            // complete the IRP
            IoCompleteRequest(Irp, IO_DISK_INCREMENT);
            // Release the IRP context
            UDFReleaseIrpContext(PtrIrpContext);
        }
    } _SEH2_END;
 
    return(RC);
} // end UDFCommonDeviceControl()